The Go Source-Level Inliner: 5 Essential Insights for Modernizing Your Code

Go 1.26 introduces a completely revamped go fix command that helps developers keep their codebases modern and maintainable. Among its many features, the source-level inliner stands out as a transformative tool for API migrations and refactorings. This article distills the core concepts and benefits into five key insights, exploring how the inliner works, its integration with gopls, and its role in enabling self-service modernizations. Whether you're a package author or a team lead, understanding these points will help you leverage Go's latest capabilities to write cleaner, more efficient code.

1. A Brand-New go fix for Modern Code

The go fix subcommand has been completely reimplemented in Go 1.26 to simplify keeping Go code up-to-date. Unlike earlier versions that relied on a handful of one-off migrations, the new go fix is modular and extensible. It includes both bespoke modernizers for specific language and library features and a powerful new general-purpose tool: the source-level inliner. This inliner acts as a self-service modernizer, enabling any package author to express simple API updates and migrations safely. By integrating with the overall go fix workflow, developers can run a single command to apply a slew of transformations, reducing manual effort and the risk of errors when upgrading dependencies or adopting new idioms.

2. What Is Source-Level Inlining?

Source-level inlining replaces a function call with a copy of the function's body, substituting actual arguments for formal parameters. The result is a durable modification to the source code itself, not just an intermediate representation. This is different from traditional compiler inlining, which optimizes generated code ephemerally. If you've used gopls's “Inline call” refactoring in VS Code (found under Source Action…), you've already witnessed this in action. The inliner takes care of many subtle correctness issues, such as handling side effects, variable scoping, and return statements, ensuring the transformed code behaves identically to the original. It's a cornerstone for automated refactoring because it preserves program semantics even when the inlined function is complex.

3. How It Differs from Compiler Inlining

While both source-level and compiler inlining replace calls with function bodies, their purposes and lifetimes differ dramatically. Compiler inlining is an optimization that operates on the compiler's internal IR, never modifying your source files. It's ephemeral and invisible to the developer. Source-level inlining, on the other hand, permanently changes your source code. This makes it ideal for refactoring tools and API migrations where you want to eliminate wrappers, simplify call sites, or adapt to new library versions. The inliner’s algorithm is designed to be safe for arbitrary code, handling edge cases like multiple returns, deferred calls, and variable shadowing. This safety ensures that after inlining, the code compiles and runs exactly as before, which is critical when applying automated changes across large codebases.

4. Integration with gopls Refactorings

The source-level inliner is already a key component of gopls, the Go language server. It powers refactorings like “Change signature” and “Remove unused parameter”. For example, when you remove a parameter, gopls needs to update every call site. Instead of rewriting each call manually, it can inline the old function into each call and then adjust the definition. This leverages the inliner's correctness guarantees to avoid introducing bugs. The inliner also underlies the “Inline call” action, which is handy for eliminating temporary variables or simplifying expressions. Because the inliner is shared between gopls and go fix, developers get consistent, high-quality transformations whether they work interactively in their editor or batch-process with the command line.

5. Self-Service API Migrations with go fix

The most exciting aspect of the source-level inliner is its ability to enable self-service migrations. Package authors can write a simple migration rule that tells go fix to replace a deprecated function call with an inline expansion of the new API. For instance, if a library transitions from DoSomething(x) to a more efficient pattern, the package maintainer can provide a fix that uses source-level inlining to rewrite client code. This lifts the burden from downstream users, who only need to run go fix to update their code. The inliner handles the mechanical transformation, including argument reordering, default parameters, and other complexities. This approach is far more scalable than one-off scripts and safer than manual edits, making it a win for both package authors and consumers.

In summary, the source-level inliner in Go 1.26's go fix is a game-changer for code modernization. It combines the precision of a compiler-like transformation with the durability of source-code edits. By understanding how it works and where it’s used — from interactive refactoring in gopls to automated batch migrations — you can take full advantage of this powerful tool. Whether you're cleaning up legacy code or guiding your team through an API upgrade, the inliner ensures your changes are correct and your code stays up-to-date with minimal hassle.