Go 1.26 introduced a redesigned go fix command that empowers developers to keep their code modern and consistent. A key innovation within this tool is the source-level inliner—a self-service mechanism that lets package authors define simple API migrations and updates. Unlike compiler inlining, which optimizes code behind the scenes, source-level inlining durably transforms your source code, making it a powerful ally for refactoring and maintaining large codebases. Below, we answer common questions about this feature to help you understand its purpose, usage, and impact.
1. What is the source-level inliner and how does it differ from compiler inlining?
The source-level inliner is a tool that replaces a function call with a copy of the function’s body, substituting arguments for parameters—but it does so at the source code level, permanently modifying your files. This contrasts with compiler inlining, where the Go compiler applies a similar transformation to its internal intermediate representation to generate faster machine code. Compiler inlining is invisible to the developer and doesn’t alter your source. The source-level inliner, on the other hand, changes the actual .go files, making the resulting code explicit and easy to review. It’s the same engine used by gopls’ “Inline call” refactoring, ensuring accuracy and handling tricky edge cases like side effects and multiple returns.
2. How can package authors use the source-level inliner for API migrations?
Any package author can leverage the source-level inliner to define simple API migrations or upgrades. This is achieved through self-service modernizers that are part of the new go fix framework. For example, you can create a fix rule that replaces calls to a deprecated function with calls to a new one, or inlines a simple helper function into its call sites. The inliner handles substitution correctly, avoiding common pitfalls like variable shadowing or multiple evaluations of arguments with side effects. To use it, you write a small declarative rule (often in JSON or Go code) that specifies the old and new patterns. Once integrated into go fix, running go fix on a project will automatically apply these transformations across all source files, saving countless hours of manual work.
3. What role does the source-level inliner play in the redesigned go fix?
The source-level inliner is one of the core analyzers within the all-new go fix command. While go fix includes several bespoke modernizers for specific language and library changes (like updates to slices or maps packages), the inliner serves as a general-purpose building block for a wide range of transformations. By providing a safe and precise inlining mechanism, it enables the creation of “self-service” modernizers—anyone can write a rule that globally replaces a function call pattern. This makes go fix extensible and community-driven, rather than relying solely on the Go team to author each migration. The inliner’s correctness guarantees are critical here: it carefully renames variables, inserts parentheses to preserve precedence, and avoids duplicating side-effectful expressions.
4. How does the inliner ensure correctness when refactoring function calls?
Inlining a function call seems simple but is fraught with subtle issues. The source-level inliner handles them all: it renames variables to avoid name conflicts with the surrounding scope, it wraps expressions in parentheses to maintain operator precedence, and it duplicates arguments only if they are pure (side-effect-free). For arguments that have side effects, it introduces temporary variables to ensure they are evaluated exactly once. It also deals with multiple return values by creating the appropriate assignments. Additionally, the inliner correctly handles edge cases like closures, generics, and deferred functions. By automating these details, the inliner removes the risk of introducing bugs during manual refactoring, making it a reliable tool for large-scale code changes.
5. What are some practical use cases for the source-level inliner beyond go fix?
Beyond its integration in go fix, the source-level inliner is a cornerstone of several gopls refactorings. For instance, the “Change signature” and “Remove unused parameter” refactorings rely on the inliner to safely modify function calls throughout the workspace. When you change a function’s signature, gopls can inline the old calls and then recreate them with the new signature, ensuring all references are consistent. Another use case is in IDEs: the “Inline call” code action (available under “Source Action…” in VS Code) lets you interactively inline any function call—perfect for simplifying code during code reviews or when you want to eliminate a trivial wrapper. The inliner’s presence in these tools means that any transformation that involves replacing a call with its body can be done reliably and instantly.
6. How does the source-level inliner handle complex constructs like closures, generics, or deferred calls?
The source-level inliner is designed to handle the full richness of Go. For closures, when inlining a function that captures variables, the inliner preserves those captures by creating the necessary closure structure inside the caller. For generics, it works at the instantiated level—when a generic function is called with concrete type arguments, the inliner can expand the body with those types fixed. For deferred calls, inlining a function that is deferred requires careful handling to ensure the function’s arguments are evaluated at the time of the defer statement, not later—the inliner correctly maintains this semantics. Additionally, it correctly handles functions with go statements, panic/recover, and type switches. This robustness is why the inliner can safely be used in an automated tool like go fix, where there may be no human review before applying hundreds of changes.