10 Game-Changing Facts About Go 1.26's Source-Level Inliner in //go:fix
Go 1.26 introduces a revolutionary new //go:fix inline and source-level inliner, a key component of the redesigned go fix tool. This all-new subcommand helps you keep your Go code modern and up-to-date. In this article, we’ll uncover ten essential facts about the source-level inliner—from its role in self-service API migrations to its deep integration with gopls. Whether you’re a package author or a daily Go developer, understanding these facts will transform how you approach code maintenance.
1. What Is the Source-Level Inliner?
The source-level inliner is a new algorithm built in 2023 that replaces a function call with the body of the called function, substituting arguments for parameters—directly in your source code. Unlike a compiler’s inliner, which works on an intermediate representation for performance gains, this transformation is durable and human-readable. It allows you to see the inlined code in your editor, making it perfect for refactoring tools and automated migrations. Under the hood, it handles complex details like renaming variables, preserving side effects, and maintaining correctness across different contexts.
2. It’s the Engine Behind gopls’ “Inline Call” Refactoring
If you’ve used the “Inline call” code action in Visual Studio Code (via the Source Action… menu), you’ve already benefited from the source-level inliner. This feature enables you to select any call expression and instantly replace it with the inlined function body. The result is a clean, modified source file with no lingering call syntax. The inliner ensures that all parameter substitutions are safe—even in complex cases like closures or defer statements. This makes everyday refactoring not only possible but effortless.
3. It Enables Self-Service API Migrations via go fix
The same inliner powers the all-new go fix command, giving any package author a “self-service” way to write custom modernizers. Instead of waiting for official Go releases, you can define simple rules to migrate users from old APIs to new ones. The inliner processes these rules, transforming calls across entire codebases. This lowers the barrier for library maintainers to deprecate functions and introduce replacements, making API evolution smoother for the entire ecosystem.
4. It Handles Subtle Correctness Issues Automatically
Refactoring function calls isn’t trivial—issues like name shadowing, side effects in arguments, and multiple returns require careful handling. The source-level inliner systematically avoids these pitfalls. For instance, if an argument expression has side effects, the inliner ensures it’s evaluated only once and at the correct point. If the called function uses defer, the transformation preserves its semantics. These details are automatically managed, so you can trust the result without manual review.
5. It’s Used in “Change Signature” and “Remove Unused Parameter” Refactorings
Gopls relies on the inliner for more advanced refactorings. When you want to change a function’s signature or remove an unused parameter, the tool internally uses inlining to rewrite call sites. It first inlines the old function body into each call, then updates the function definition, and often re-extracts the new version. This two-step process, powered by the inliner, ensures that no call site is left broken. It’s a prime example of how low-level building blocks enable high-level editor features.
6. It’s Source-Code Durable, Not Ephemeral
Unlike compiler inlining, which is invisible to developers except through performance, source-level inlining permanently modifies your source files. This means you can commit the result to version control, review it in code reviews, and run tests against it. The transformation is explicit and auditable. For API migrations, this durability gives developers confidence—they can see exactly what changed and can easily roll back if something goes wrong.
7. It Integrates Seamlessly with the //go:fix Directive
The new //go:fix comments allow package authors to annotate functions with inline instructions. For example, you can mark a deprecated function with a directive that tells go fix to replace its calls with a new version. The inliner then processes these directives during a go fix run. This makes the upgrade path automatic, consistent, and well-documented—no more manual find-and-replace or obscure shell scripts.
8. It Supports Complex Call Patterns
The algorithm isn’t limited to simple function calls. It can handle methods on structs, generic functions, calls with variadic arguments, and even calls that use type parameters. For instance, inlining a generic function ensures that the type parameter is properly instantiated at each call site. This breadth makes it suitable for modern Go codebases that heavily use generics. The inliner also respects go: directives and build constraints, ensuring portability across platforms.
9. It’s a Foundational Step Toward Automated Modernization
The source-level inliner is the first fruit of the Go team’s effort to provide self-service modernizers and analyzers. Future releases will build on this technology to offer even more automated upgrades. By making the inliner an open, reusable component, the Go ecosystem gains the ability to evolve APIs faster and with fewer errors. This is a paradigm shift from waiting for the compiler to deprecate idioms to proactively migrating codebases at scale.
10. Getting Started Is Easy: Try It Today
To use the source-level inliner, simply install Go 1.26 and open a project. In VS Code, trigger the “Inline call” action from the Source Action menu. For API migrations, add a //go:fix comment to the deprecated function and run go fix ./.... The tool outputs clean, ready-to-compile code. Start with a small test function to see the transform in action—the clarity and safety will immediately convince you. For more details, read the official Go blog post on //go:fix and the source-level inliner.
The source-level inliner is more than a tool—it’s a new way to think about code evolution. By combining durability, correctness, and self-service capabilities, it empowers every Go developer to keep their codebases modern without sacrificing safety. As Go continues to mature, expect this technology to become a cornerstone of automated refactoring and upgrade workflows. Start experimenting today and see how it can transform your development process.