Understanding Go's Source-Level Inliner and the New go fix Command

Go 1.26 introduces a revamped go fix subcommand that helps developers keep their code modern and up-to-date. A standout feature is the source-level inliner, which allows package authors to perform safe, automated API migrations and code transformations. This article answers common questions about the source-level inliner and its role in the new go fix ecosystem.

What is the source-level inliner in Go?

The source-level inliner is a tool that replaces a function call with a copy of the function's body, substituting actual arguments for parameters. Unlike compiler inlining, which works on ephemeral intermediate representations to optimize performance, source-level inlining makes permanent changes to your source code. This transformation is critical for refactoring tasks, such as the “Inline call” feature in gopls. In Go 1.26, the same inliner is now part of go fix, enabling self-service API migrations. For example, if a library updates its API, package authors can define rules that automatically inline old calls into new patterns, reducing manual effort and the risk of errors.

How does source-level inlining differ from compiler inlining?

Compiler inlining is an optimization step that occurs during compilation, where the compiler replaces a call with the function's body to avoid function call overhead. This happens internally in the compiler's intermediate representation and does not alter the source code you maintain. In contrast, source-level inlining modifies your .go files directly. It is a durable transformation that you can commit to version control. The Go compiler's inliner is focused on performance and makes conservative decisions based on heuristics, while the source-level inliner prioritizes correctness and flexibility for refactoring. It handles complex cases like closures, deferred calls, and generic functions, ensuring that the resulting code is semantically equivalent to the original.

How can I use the source-level inliner with go fix?

Starting in Go 1.26, the go fix command includes the source-level inliner as one of its built-in analyzers. To use it, simply run go fix ./... in your project. If a package author has provided inline rules for their API (using //go:fix inline directives), go fix will automatically apply those transformations to your code. For example, suppose a library replaces a Sum function with a new AddAll method. The library maintainer can define an inlining rule so that calls to Sum are replaced with the equivalent AddAll invocation. You don't need to write any custom tooling—just run go fix and your code updates seamlessly. This is ideal for keeping large codebases up-to-date with minimal effort.

What are the benefits of self-service API migration via go fix?

The key benefit is reduced migration burden. When libraries change their APIs, downstream users often face a tedious manual update process. With go fix, library authors can encode migration rules that automatically transform old usage patterns into new ones. This eliminates human error and enforces consistency across the codebase. Another advantage is that the source-level inliner is extremely precise: it correctly handles edge cases like variable shadowing, closures, and generics. It also integrates with other go fix analyzers, so you get a holistic update experience. For the Go ecosystem, this promotes faster adoption of language improvements and better practices, as upgrades become nearly frictionless.

How does the inliner relate to gopls refactoring features?

The source-level inliner has been a key component of gopls (the Go language server) for some time. Gopls uses it in interactive refactorings like “Inline call” (available via the “Source Action…” menu in VS Code). When you request to inline a function call, gopls runs the same algorithm that now powers go fix. Additionally, refactorings such as “Change signature” and “Remove unused parameter” rely on the inliner to safely propagate changes. By reusing the inliner in both interactive and batch modes, Go provides a consistent transformation experience whether you're refactoring a single call or updating an entire repository with go fix.

What technical challenges does the source-level inliner overcome?

Inlining sounds simple in theory, but implementing a correct source-level inliner is surprisingly complex. One challenge is name collision: when the function body uses identifiers that clash with names in the caller's scope, the inliner must rename them to avoid shadowing. Another is handling closures and deferred calls, which have different evaluation semantics. The inliner must also correctly treat return statements: after inlining, what was a return in the callee might become an assignment or early exit. For generic functions, the inliner must instantiate type parameters properly. The Go team solved these problems by building the inliner on top of the go/types package, which provides full type information and scope analysis, ensuring that every transformation is safe and preserves the original meaning.

What future extensions can we expect for go fix and the inliner?

The go fix infrastructure is designed to be extensible. The team plans to add more “self-service” analyzers beyond the source-level inliner. For instance, package authors might be able to define rules for renaming functions, changing return patterns, or even splitting packages—all automatically. The inliner itself will continue to improve, with better support for complex generic cases and performance optimizations. Ultimately, the goal is to make Go code modernization a first-class, low-friction part of the development workflow. By sharing the same underlying engine with gopls, these improvements will benefit both interactive and batch scenarios, keeping Go codebases clean and up-to-date with minimal manual intervention.