Go 1.26's Source-Level Inliner: Simplifying API Migrations

Introduction

With the release of Go 1.26, the go fix subcommand has received a complete overhaul. Designed to help developers keep their codebases modern and compliant with the latest language features, the new go fix now includes a powerful source-level inliner. This tool is the first step toward providing “self-service” modernizers and analyzers that any package author can use to express simple API migrations and updates safely and efficiently.

What Is Source-Level Inlining?

In programming, inlining refers to replacing a function call with a copy of the function’s body, substituting the actual arguments for the parameters. Traditional compilers perform inlining on an internal representation to generate more optimized code. However, Go 1.26 introduces source-level inlining, which applies this transformation directly to the source code, permanently modifying it.

If you have used the “Inline call” refactoring in gopls (available through the Source Action menu in VS Code), you have already experienced this technology. For instance, given a function sum(a, b int) int { return a + b } and a call sum(1, 2), source-level inlining would replace the call with 1 + 2.

Benefits Over Compiler Inlining

Source-level inlining offers several advantages:

• Permanent changes: The transformation is applied to the actual source files, not just to an intermediate representation.
• Readable output: The resulting code is clear and maintainable, making it ideal for refactoring and migration tasks.
• Safe refactoring: The inliner automatically handles subtle issues like variable shadowing, side effects, and order of evaluation.

How the Inliner Works in go fix

The source-level inliner is one of the analyzers integrated into the new go fix command. When you run go fix, it scans your code for patterns that match known migrations. For each pattern, the inliner applies the corresponding inline transformation, updating the source code accordingly.

For example, suppose a library authors deprecate a function OldFunc(x) in favor of NewFunc(x). By providing a simple rule, the inliner can automatically replace all calls to OldFunc with something equivalent—often by inlining the old function’s body and then applying additional transformations.

Self-Service Modernizers

The real power of this approach is its extensibility. Package authors can now write their own “modernizers” for API changes without waiting for the Go team to include them in the standard toolchain. This is similar to how go vet allows custom analyzers, but focused on source-to-source transformations.

To create a self-service modernizer, you define an inline rule specifying:

1. The target pattern: the function call to be replaced.
2. The replacement template: the code to substitute, possibly referencing arguments.
3. Any prerequisites: conditions that must hold for the transformation to be safe.

The inliner then applies these rules across the entire package, ensuring correctness even in complex cases.

Technical Challenges

Building a source-level inliner that works reliably in all scenarios is non-trivial. The Go team had to solve several difficult problems:

• Variable name conflicts: Inlining can introduce new variables that clash with existing ones. The inliner automatically renames to avoid collisions.
• Side effects and evaluation order: Arguments with side effects (e.g., function calls) must be evaluated exactly once and in the correct order. The inliner introduces temporary variables when necessary.
• Control flow complexity: Functions with multiple return points, loops, or deferred calls require careful handling. The inliner is designed to preserve the exact semantics of the original program.
• Composability: Inlining can trigger further inlinings or other modernizers. The new go fix runs all analyses in a strategic order to maximize correctness and coverage.

Integration with gopls

The same inlining algorithm is already used by gopls for interactive refactorings like Change Signature and Remove Unused Parameter. These operations also involve inlining function calls internally. The reimplementation in Go 1.26 unifies the codebase, making future improvements easier to deploy across both command-line and editor contexts.

Conclusion

The source-level inliner in Go 1.26 marks a significant step forward for code modernization. By enabling self-service API migrations and safe, durable transformations, it empowers package authors to keep their ecosystems healthy without manual effort. Whether you are a library maintainer looking to deprecate old APIs or a developer wanting to automate repetitive refactoring, this tool promises to save time and reduce errors. To get started, upgrade to Go 1.26 and run go fix on your projects—the future of automated code cleanup has arrived.

For a deeper dive, read the official Go blog post on the new go fix.