gopls/internal/lsp/source: implement refactor.inline code action

This change uses the new inlining package to implement
the refactor.inline code action.

Fixes golang/go#59243

Change-Id: I9455e1989c6e077849c72924e336c0c738c5cebc
Reviewed-on: https://go-review.googlesource.com/c/tools/+/523696
Reviewed-by: Robert Findley <[email protected]>
gopls-CI: kokoro <[email protected]>
Run-TryBot: Alan Donovan <[email protected]>
TryBot-Result: Gopher Robot <[email protected]>

Author: adonovan

gopls/internal/lsp/cmd/cmd.go

@@ -524,7 +524,10 @@ func (c *cmdClient) Configuration(ctx context.Context, p *protocol.ParamConfigur
 }
 
 func (c *cmdClient) ApplyEdit(ctx context.Context, p *protocol.ApplyWorkspaceEditParams) (*protocol.ApplyWorkspaceEditResult, error) {
-	return &protocol.ApplyWorkspaceEditResult{Applied: false, FailureReason: "not implemented"}, nil
+	return &protocol.ApplyWorkspaceEditResult{
+		Applied:       false,
+		FailureReason: "the gopls command-line client does not apply edits",
+	}, nil
 }
 
 func (c *cmdClient) PublishDiagnostics(ctx context.Context, p *protocol.PublishDiagnosticsParams) error {

gopls/internal/lsp/cmd/suggested_fix.go

@@ -101,12 +101,30 @@ func (s *suggestedFix) Run(ctx context.Context, args ...string) error {
 	// Gather edits from matching code actions.
 	var edits []protocol.TextEdit
 	for _, a := range actions {
-		if a.Command != nil {
-			return fmt.Errorf("ExecuteCommand is not yet supported on the command line (action: %v)", a.Title)
-		}
+		// Without -all, apply only "preferred" fixes.
 		if !a.IsPreferred && !s.All {
 			continue
 		}
+
+		// Execute any command.
+		// This may cause the server to make
+		// an ApplyEdit downcall to the client.
+		if a.Command != nil {
+			if _, err := conn.ExecuteCommand(ctx, &protocol.ExecuteCommandParams{
+				Command:   a.Command.Command,
+				Arguments: a.Command.Arguments,
+			}); err != nil {
+				return err
+			}
+			// The specification says that commands should
+			// be executed _after_ edits are applied, not
+			// instead of them, but we don't want to
+			// duplicate edits.
+			continue
+		}
+
+		// Partially apply CodeAction.Edit, a WorkspaceEdit.
+		// (See also conn.Client.applyWorkspaceEdit(a.Edit)).
 		if !from.HasPosition() {
 			for _, c := range a.Edit.DocumentChanges {
 				if c.TextDocumentEdit != nil {

gopls/internal/lsp/code_action.go

@@ -194,7 +194,10 @@ func (s *Server) codeAction(ctx context.Context, params *protocol.CodeActionPara
 		}
 
 		// Code actions requiring type information.
-		if len(stubMethodsDiagnostics) > 0 || want[protocol.RefactorRewrite] || want[protocol.GoTest] {
+		if len(stubMethodsDiagnostics) > 0 ||
+			want[protocol.RefactorRewrite] ||
+			want[protocol.RefactorInline] ||
+			want[protocol.GoTest] {
 			pkg, pgf, err := source.NarrowestPackageForFile(ctx, snapshot, fh.URI())
 			if err != nil {
 				return nil, err
@@ -250,6 +253,14 @@ func (s *Server) codeAction(ctx context.Context, params *protocol.CodeActionPara
 				actions = append(actions, rewrites...)
 			}
 
+			if want[protocol.RefactorInline] {
+				rewrites, err := refactorInline(ctx, snapshot, pkg, pgf, fh, params.Range)
+				if err != nil {
+					return nil, err
+				}
+				actions = append(actions, rewrites...)
+			}
+
 			if want[protocol.GoTest] {
 				fixes, err := goTest(ctx, snapshot, pkg, pgf, params.Range)
 				if err != nil {
@@ -499,6 +510,35 @@ func refactorRewrite(ctx context.Context, snapshot source.Snapshot, pkg source.P
 	return actions, nil
 }
 
+// refactorInline returns inline actions available at the specified range.
+func refactorInline(ctx context.Context, snapshot source.Snapshot, pkg source.Package, pgf *source.ParsedGoFile, fh source.FileHandle, rng protocol.Range) ([]protocol.CodeAction, error) {
+	var commands []protocol.Command
+
+	// If range is within call expression, offer inline action.
+	if _, fn, err := source.EnclosingStaticCall(pkg, pgf, rng); err == nil {
+		cmd, err := command.NewApplyFixCommand(fmt.Sprintf("Inline call to %s", fn.Name()), command.ApplyFixArgs{
+			URI:   protocol.URIFromSpanURI(pgf.URI),
+			Fix:   source.InlineCall,
+			Range: rng,
+		})
+		if err != nil {
+			return nil, err
+		}
+		commands = append(commands, cmd)
+	}
+
+	// Convert commands to actions.
+	var actions []protocol.CodeAction
+	for i := range commands {
+		actions = append(actions, protocol.CodeAction{
+			Title:   commands[i].Title,
+			Kind:    protocol.RefactorInline,
+			Command: &commands[i],
+		})
+	}
+	return actions, nil
+}
+
 func documentChanges(fh source.FileHandle, edits []protocol.TextEdit) []protocol.DocumentChanges {
 	return []protocol.DocumentChanges{
 		{

gopls/internal/lsp/source/fix.go

@@ -35,13 +35,16 @@ type (
 	singleFileFixFunc func(fset *token.FileSet, start, end token.Pos, src []byte, file *ast.File, pkg *types.Package, info *types.Info) (*analysis.SuggestedFix, error)
 )
 
+// These strings identify kinds of suggested fix, both in Analyzer.Fix
+// and in the ApplyFix subcommand (see ExecuteCommand and ApplyFixArgs.Fix).
 const (
 	FillStruct        = "fill_struct"
 	StubMethods       = "stub_methods"
 	UndeclaredName    = "undeclared_name"
 	ExtractVariable   = "extract_variable"
 	ExtractFunction   = "extract_function"
 	ExtractMethod     = "extract_method"
+	InlineCall        = "inline_call"
 	InvertIfCondition = "invert_if_condition"
 	AddEmbedImport    = "add_embed_import"
 )
@@ -51,6 +54,7 @@ var suggestedFixes = map[string]SuggestedFixFunc{
 	FillStruct:        singleFile(fillstruct.SuggestedFix),
 	UndeclaredName:    singleFile(undeclaredname.SuggestedFix),
 	ExtractVariable:   singleFile(extractVariable),
+	InlineCall:        inlineCall,
 	ExtractFunction:   singleFile(extractFunction),
 	ExtractMethod:     singleFile(extractMethod),
 	InvertIfCondition: singleFile(invertIfCondition),

gopls/internal/lsp/source/inline.go

@@ -0,0 +1,113 @@
+// Copyright 2023 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package source
+
+// This file defines the refactor.inline code action.
+
+import (
+	"context"
+	"fmt"
+	"go/ast"
+	"go/token"
+	"go/types"
+
+	"golang.org/x/tools/go/analysis"
+	"golang.org/x/tools/go/ast/astutil"
+	"golang.org/x/tools/go/types/typeutil"
+	"golang.org/x/tools/gopls/internal/lsp/protocol"
+	"golang.org/x/tools/gopls/internal/lsp/safetoken"
+	"golang.org/x/tools/gopls/internal/span"
+	"golang.org/x/tools/internal/diff"
+	"golang.org/x/tools/internal/refactor/inline"
+)
+
+// EnclosingStaticCall returns the innermost function call enclosing
+// the selected range, along with the callee.
+func EnclosingStaticCall(pkg Package, pgf *ParsedGoFile, rng protocol.Range) (*ast.CallExpr, *types.Func, error) {
+	start, end, err := pgf.RangePos(rng)
+	if err != nil {
+		return nil, nil, err
+	}
+	path, _ := astutil.PathEnclosingInterval(pgf.File, start, end)
+
+	var call *ast.CallExpr
+loop:
+	for _, n := range path {
+		switch n := n.(type) {
+		case *ast.FuncLit:
+			break loop
+		case *ast.CallExpr:
+			call = n
+			break loop
+		}
+	}
+	if call == nil {
+		return nil, nil, fmt.Errorf("no enclosing call")
+	}
+	if safetoken.Line(pgf.Tok, call.Lparen) != safetoken.Line(pgf.Tok, start) {
+		return nil, nil, fmt.Errorf("enclosing call is not on this line")
+	}
+	fn := typeutil.StaticCallee(pkg.GetTypesInfo(), call)
+	if fn == nil {
+		return nil, nil, fmt.Errorf("not a static call to a Go function")
+	}
+	return call, fn, nil
+}
+
+func inlineCall(ctx context.Context, snapshot Snapshot, fh FileHandle, rng protocol.Range) (*token.FileSet, *analysis.SuggestedFix, error) {
+	// Find enclosing static call.
+	callerPkg, callerPGF, err := NarrowestPackageForFile(ctx, snapshot, fh.URI())
+	if err != nil {
+		return nil, nil, err
+	}
+	call, fn, err := EnclosingStaticCall(callerPkg, callerPGF, rng)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	// Locate callee by file/line and analyze it.
+	calleePosn := safetoken.StartPosition(callerPkg.FileSet(), fn.Pos())
+	calleePkg, calleePGF, err := NarrowestPackageForFile(ctx, snapshot, span.URIFromPath(calleePosn.Filename))
+	if err != nil {
+		return nil, nil, err
+	}
+	var calleeDecl *ast.FuncDecl
+	for _, decl := range calleePGF.File.Decls {
+		if decl, ok := decl.(*ast.FuncDecl); ok {
+			posn := safetoken.StartPosition(calleePkg.FileSet(), decl.Name.Pos())
+			if posn.Line == calleePosn.Line && posn.Column == calleePosn.Column {
+				calleeDecl = decl
+				break
+			}
+		}
+	}
+	if calleeDecl == nil {
+		return nil, nil, fmt.Errorf("can't find callee")
+	}
+	callee, err := inline.AnalyzeCallee(calleePkg.FileSet(), calleePkg.GetTypes(), calleePkg.GetTypesInfo(), calleeDecl, calleePGF.Src)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	// Inline the call.
+	caller := &inline.Caller{
+		Fset:    callerPkg.FileSet(),
+		Types:   callerPkg.GetTypes(),
+		Info:    callerPkg.GetTypesInfo(),
+		File:    callerPGF.File,
+		Call:    call,
+		Content: callerPGF.Src,
+	}
+	got, err := inline.Inline(caller, callee)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	// Suggest the fix.
+	return callerPkg.FileSet(), &analysis.SuggestedFix{
+		Message:   fmt.Sprintf("inline call of %v", callee),
+		TextEdits: diffToTextEdits(callerPGF.Tok, diff.Bytes(callerPGF.Src, got)),
+	}, nil
+}

gopls/internal/lsp/source/options.go

@@ -104,6 +104,7 @@ func DefaultOptions() *Options {
 						protocol.SourceOrganizeImports: true,
 						protocol.QuickFix:              true,
 						protocol.RefactorRewrite:       true,
+						protocol.RefactorInline:        true,
 						protocol.RefactorExtract:       true,
 					},
 					Mod: {

gopls/internal/lsp/source/stub.go

@@ -22,6 +22,7 @@ import (
 	"golang.org/x/tools/gopls/internal/lsp/analysis/stubmethods"
 	"golang.org/x/tools/gopls/internal/lsp/protocol"
 	"golang.org/x/tools/gopls/internal/lsp/safetoken"
+	"golang.org/x/tools/internal/diff"
 	"golang.org/x/tools/internal/tokeninternal"
 	"golang.org/x/tools/internal/typeparams"
 )
@@ -231,15 +232,19 @@ func (%s%s%s) %s%s {
 
 	// Report the diff.
 	diffs := snapshot.View().Options().ComputeEdits(string(input), output.String())
-	var edits []analysis.TextEdit
+	return tokeninternal.FileSetFor(declPGF.Tok), // edits use declPGF.Tok
+		&analysis.SuggestedFix{TextEdits: diffToTextEdits(declPGF.Tok, diffs)},
+		nil
+}
+
+func diffToTextEdits(tok *token.File, diffs []diff.Edit) []analysis.TextEdit {
+	edits := make([]analysis.TextEdit, 0, len(diffs))
 	for _, edit := range diffs {
 		edits = append(edits, analysis.TextEdit{
-			Pos:     declPGF.Tok.Pos(edit.Start),
-			End:     declPGF.Tok.Pos(edit.End),
+			Pos:     tok.Pos(edit.Start),
+			End:     tok.Pos(edit.End),
 			NewText: []byte(edit.New),
 		})
 	}
-	return tokeninternal.FileSetFor(declPGF.Tok), // edits use declPGF.Tok
-		&analysis.SuggestedFix{TextEdits: edits},
-		nil
+	return edits
 }

gopls/internal/lsp/tests/tests.go

@@ -230,6 +230,7 @@ func DefaultOptions(o *source.Options) {
 			protocol.SourceOrganizeImports: true,
 			protocol.QuickFix:              true,
 			protocol.RefactorRewrite:       true,
+			protocol.RefactorInline:        true,
 			protocol.RefactorExtract:       true,
 			protocol.SourceFixAll:          true,
 		},

gopls/internal/regtest/marker/testdata/codeaction/inline.txt

@@ -0,0 +1,23 @@
+This is a minimal test of the refactor.inline code action.
+
+-- go.mod --
+module testdata/codeaction
+go 1.18
+
+-- a/a.go --
+package a
+
+func _() {
+	println(add(1, 2)) //@codeaction("refactor.inline", "add", ")", inline)
+}
+
+func add(x, y int) int { return x + y }
+
+-- @inline/a/a.go --
+package a
+
+func _() {
+	println(func(x, y int) int { return x + y }(1, 2)) //@codeaction("refactor.inline", "add", ")", inline)
+}
+
+func add(x, y int) int { return x + y }