x/tools/gopls: implement struct field generation quickfix

Author: dennypenta

gopls/doc/features/diagnostics.md

@@ -248,6 +248,35 @@ func doSomething(i int) string {
   panic("unimplemented")
 }
 ```
+
+### `StubMissingStructField`: Declare missing field T.f
+
+When you attempt to access a field on a type that does not have the field,
+the compiler will report an error such as "type X has no field or method Y".
+In this scenario, gopls now offers a quick fix to generate a stub declaration of
+the missing field, inferring its type from the accessing type or assigning a designated value.
+
+Consider the following code where `Foo` does not have a field `bar`:
+
+```go
+type Foo struct{}
+
+func main() {
+  var s string
+  f := Foo{}
+  s = f.bar // error: f.bar undefined (type Foo has no field or method bar)
+}
+```
+
+Gopls will offer a quick fix, "Declare missing field Foo.bar".
+When invoked, it creates the following declaration:
+
+```go
+type Foo struct{
+  bar string
+}
+```
+
 <!--
 
 dorky details and deletia:

gopls/doc/release/v0.17.0.md

@@ -113,4 +113,12 @@ into account its signature, including input parameters and results.
 Since this feature is implemented by the server (gopls), it is compatible with
 all LSP-compliant editors. VS Code users may continue to use the client-side
 `Go: Generate Unit Tests For file/function/package` command which utilizes the
-[gotests](https://github.com/cweill/gotests) tool.
+[gotests](https://github.com/cweill/gotests) tool.
+
+## Generate missing struct field from access
+When you attempt to access a field on a type that does not have the field,
+the compiler will report an error like “type X has no field or method Y”.
+Gopls now offers a new code action, “Declare missing field of T.f”,
+where T is the concrete type and f is the undefined field.
+The stub field's signature is inferred
+from the context of the access.

gopls/internal/analysis/yield/testdata/src/a/a.go

@@ -83,7 +83,6 @@ func tricky(in io.ReadCloser) func(yield func(string, error) bool) {
 		}
 	}
 }
-<<<<<<< HEAD
 
 // Regression test for issue #70598.
 func shortCircuitAND(yield func(int) bool) {
@@ -119,5 +118,3 @@ func tricky3(yield func(int) bool) {
 		yield(3)
 	}
 }
-=======
->>>>>>> 9b6e4f21d (gopls/internal/analysis/yield: analyzer for iterator (yield) mistakes)

gopls/internal/analysis/yield/yield.go

@@ -20,10 +20,7 @@ import (
 	_ "embed"
 	"fmt"
 	"go/ast"
-<<<<<<< HEAD
 	"go/constant"
-=======
->>>>>>> 9b6e4f21d (gopls/internal/analysis/yield: analyzer for iterator (yield) mistakes)
 	"go/token"
 	"go/types"
 
@@ -123,7 +120,6 @@ func run(pass *analysis.Pass) (interface{}, error) {
 							// In that case visit only the "if !yield()" block.
 							cond := instr.Cond
 							t, f := b.Succs[0], b.Succs[1]
-<<<<<<< HEAD
 
 							// Strip off any NOT operator.
 							cond, t, f = unnegate(cond, t, f)
@@ -152,11 +148,6 @@ func run(pass *analysis.Pass) (interface{}, error) {
 								}
 							}
 
-=======
-							if unop, ok := cond.(*ssa.UnOp); ok && unop.Op == token.NOT {
-								cond, t, f = unop.X, f, t
-							}
->>>>>>> 9b6e4f21d (gopls/internal/analysis/yield: analyzer for iterator (yield) mistakes)
 							if cond, ok := cond.(*ssa.Call); ok && ssaYieldCalls[cond] != nil {
 								// Skip the successor reached by "if yield() { ... }".
 							} else {
@@ -178,13 +169,10 @@ func run(pass *analysis.Pass) (interface{}, error) {
 
 	return nil, nil
 }
-<<<<<<< HEAD
 
 func unnegate(cond ssa.Value, t, f *ssa.BasicBlock) (_ ssa.Value, _, _ *ssa.BasicBlock) {
 	if unop, ok := cond.(*ssa.UnOp); ok && unop.Op == token.NOT {
 		return unop.X, f, t
 	}
 	return cond, t, f
 }
-=======
->>>>>>> 9b6e4f21d (gopls/internal/analysis/yield: analyzer for iterator (yield) mistakes)

gopls/internal/analysis/yield/yield_test.go

@@ -15,4 +15,3 @@ func Test(t *testing.T) {
 	testdata := analysistest.TestData()
 	analysistest.Run(t, testdata, yield.Analyzer, "a")
 }
-e

gopls/internal/doc/api.json

@@ -1304,15 +1304,12 @@
 			"Default": false
 		},
 		{
-<<<<<<< HEAD
 			"Name": "waitgroup",
 			"Doc": "check for misuses of sync.WaitGroup\n\nThis analyzer detects mistaken calls to the (*sync.WaitGroup).Add\nmethod from inside a new goroutine, causing Add to race with Wait:\n\n\t// WRONG\n\tvar wg sync.WaitGroup\n\tgo func() {\n\t        wg.Add(1) // \"WaitGroup.Add called from inside new goroutine\"\n\t        defer wg.Done()\n\t        ...\n\t}()\n\twg.Wait() // (may return prematurely before new goroutine starts)\n\nThe correct code calls Add before starting the goroutine:\n\n\t// RIGHT\n\tvar wg sync.WaitGroup\n\twg.Add(1)\n\tgo func() {\n\t\tdefer wg.Done()\n\t\t...\n\t}()\n\twg.Wait()",
 			"URL": "https://pkg.go.dev/golang.org/x/tools/go/analysis/passes/waitgroup",
 			"Default": true
 		},
 		{
-=======
->>>>>>> 9b6e4f21d (gopls/internal/analysis/yield: analyzer for iterator (yield) mistakes)
 			"Name": "yield",
 			"Doc": "report calls to yield where the result is ignored\n\nAfter a yield function returns false, the caller should not call\nthe yield function again; generally the iterator should return\npromptly.\n\nThis example fails to check the result of the call to yield,\ncausing this analyzer to report a diagnostic:\n\n\tyield(1) // yield may be called again (on L2) after returning false\n\tyield(2)\n\nThe corrected code is either this:\n\n\tif yield(1) { yield(2) }\n\nor simply:\n\n\t_ = yield(1) \u0026\u0026 yield(2)\n\nIt is not always a mistake to ignore the result of yield.\nFor example, this is a valid single-element iterator:\n\n\tyield(1) // ok to ignore result\n\treturn\n\nIt is only a mistake when the yield call that returned false may be\nfollowed by another call.",
 			"URL": "https://pkg.go.dev/golang.org/x/tools/gopls/internal/analysis/yield",

gopls/internal/golang/assembly.go

@@ -1,4 +1,4 @@
-ew// Copyright 2024 The Go Authors. All rights reserved.
+// Copyright 2024 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.
 

gopls/internal/golang/codeaction.go

@@ -5,6 +5,7 @@
 package golang
 
 import (
+	"bytes"
 	"context"
 	"encoding/json"
 	"fmt"
@@ -322,14 +323,23 @@ func quickFix(ctx context.Context, req *codeActionsRequest) error {
 			}
 
 		// "type X has no field or method Y" compiler error.
-		// Offer a "Declare missing method T.f" code action.
-		// See [stubMissingCalledFunctionFixer] for command implementation.
 		case strings.Contains(msg, "has no field or method"):
 			path, _ := astutil.PathEnclosingInterval(req.pgf.File, start, end)
+
+			// Offer a "Declare missing method T.f" code action if a CallStubInfo found.
+			// See [stubMissingCalledFunctionFixer] for command implementation.
 			si := stubmethods.GetCallStubInfo(req.pkg.FileSet(), info, path, start)
 			if si != nil {
 				msg := fmt.Sprintf("Declare missing method %s.%s", si.Receiver.Obj().Name(), si.MethodName)
 				req.addApplyFixAction(msg, fixMissingCalledFunction, req.loc)
+			} else {
+				// Offer a "Declare missing field T.f" code action.
+				// See [stubMissingStructFieldFixer] for command implementation.
+				fi := GetFieldStubInfo(req.pkg.FileSet(), info, path)
+				if fi != nil {
+					msg := fmt.Sprintf("Declare missing struct field %s.%s", fi.Named.Obj().Name(), fi.Expr.Sel.Name)
+					req.addApplyFixAction(msg, fixMissingStructField, req.loc)
+				}
 			}
 
 		// "undeclared name: x" or "undefined: x" compiler error.
@@ -348,6 +358,75 @@ func quickFix(ctx context.Context, req *codeActionsRequest) error {
 	return nil
 }
 
+func GetFieldStubInfo(fset *token.FileSet, info *types.Info, path []ast.Node) *StructFieldInfo {
+	for _, node := range path {
+		n, ok := node.(*ast.SelectorExpr)
+		if !ok {
+			continue
+		}
+		tv, ok := info.Types[n.X]
+		if !ok {
+			break
+		}
+
+		named, ok := tv.Type.(*types.Named)
+		if !ok {
+			break
+		}
+
+		structType, ok := named.Underlying().(*types.Struct)
+		if !ok {
+			break
+		}
+
+		return &StructFieldInfo{
+			Fset:   fset,
+			Expr:   n,
+			Struct: structType,
+			Named:  named,
+			Info:   info,
+			Path:   path,
+		}
+	}
+
+	return nil
+}
+
+type StructFieldInfo struct {
+	Fset   *token.FileSet
+	Expr   *ast.SelectorExpr
+	Struct *types.Struct
+	Named  *types.Named
+	Info   *types.Info
+	Path   []ast.Node
+}
+
+// Emit writes to out the missing field based on type info.
+func (si *StructFieldInfo) Emit(out *bytes.Buffer, qual types.Qualifier) error {
+	if si.Expr == nil || si.Expr.Sel == nil {
+		return fmt.Errorf("invalid selector expression")
+	}
+
+	// Get types from context at the selector expression position
+	typesFromContext := typesutil.TypesFromContext(si.Info, si.Path, si.Expr.Pos())
+
+	// Default to interface{} if we couldn't determine the type from context
+	var fieldType types.Type
+	if len(typesFromContext) > 0 && typesFromContext[0] != nil {
+		fieldType = typesFromContext[0]
+	} else {
+		// Create a new interface{} type
+		fieldType = types.NewInterfaceType(nil, nil)
+	}
+
+	tpl := "\n\t%s %s"
+	if si.Struct.NumFields() == 0 {
+		tpl += "\n"
+	}
+	fmt.Fprintf(out, tpl, si.Expr.Sel.Name, types.TypeString(fieldType, qual))
+	return nil
+}
+
 // allImportsFixesResult is the result of a lazy call to allImportsFixes.
 // It implements the codeActionsRequest lazyInit interface.
 type allImportsFixesResult struct {

gopls/internal/golang/fix.go

@@ -68,6 +68,7 @@ const (
 	fixCreateUndeclared        = "create_undeclared"
 	fixMissingInterfaceMethods = "stub_missing_interface_method"
 	fixMissingCalledFunction   = "stub_missing_called_function"
+	fixMissingStructField      = "stub_missing_struct_field"
 )
 
 // ApplyFix applies the specified kind of suggested fix to the given
@@ -113,6 +114,7 @@ func ApplyFix(ctx context.Context, fix string, snapshot *cache.Snapshot, fh file
 		fixCreateUndeclared:        singleFile(CreateUndeclared),
 		fixMissingInterfaceMethods: stubMissingInterfaceMethodsFixer,
 		fixMissingCalledFunction:   stubMissingCalledFunctionFixer,
+		fixMissingStructField:      stubMissingStructFieldFixer,
 	}
 	fixer, ok := fixers[fix]
 	if !ok {

gopls/internal/golang/stub.go

@@ -8,6 +8,7 @@ import (
 	"bytes"
 	"context"
 	"fmt"
+	"go/ast"
 	"go/format"
 	"go/parser"
 	"go/token"
@@ -51,6 +52,18 @@ func stubMissingCalledFunctionFixer(ctx context.Context, snapshot *cache.Snapsho
 	return insertDeclsAfter(ctx, snapshot, pkg.Metadata(), si.Fset, si.After, si.Emit)
 }
 
+// stubMissingStructFieldFixer returns a suggested fix to declare the missing
+// field that the user may want to generate based on SelectorExpr
+// at the cursor position.
+func stubMissingStructFieldFixer(ctx context.Context, snapshot *cache.Snapshot, pkg *cache.Package, pgf *parsego.File, start, end token.Pos) (*token.FileSet, *analysis.SuggestedFix, error) {
+	nodes, _ := astutil.PathEnclosingInterval(pgf.File, start, end)
+	fi := GetFieldStubInfo(pkg.FileSet(), pkg.TypesInfo(), nodes)
+	if fi == nil {
+		return nil, nil, fmt.Errorf("invalid type request")
+	}
+	return insertStructField(ctx, snapshot, pkg.Metadata(), fi)
+}
+
 // An emitter writes new top-level declarations into an existing
 // file. References to symbols should be qualified using qual, which
 // respects the local import environment.
@@ -238,3 +251,66 @@ func trimVersionSuffix(path string) string {
 	}
 	return path
 }
+
+func insertStructField(ctx context.Context, snapshot *cache.Snapshot, meta *metadata.Package, fieldInfo *StructFieldInfo) (*token.FileSet, *analysis.SuggestedFix, error) {
+	if fieldInfo == nil {
+		return nil, nil, fmt.Errorf("no field info provided")
+	}
+
+	// get the file containing the struct definition using the position
+	declPGF, _, err := parseFull(ctx, snapshot, fieldInfo.Fset, fieldInfo.Named.Obj().Pos())
+	if err != nil {
+		return nil, nil, fmt.Errorf("failed to parse file declaring struct: %w", err)
+	}
+	if declPGF.Fixed() {
+		return nil, nil, fmt.Errorf("file contains parse errors: %s", declPGF.URI)
+	}
+
+	// find the struct type declaration
+	var structType *ast.StructType
+	ast.Inspect(declPGF.File, func(n ast.Node) bool {
+		if typeSpec, ok := n.(*ast.TypeSpec); ok {
+			if typeSpec.Name.Name == fieldInfo.Named.Obj().Name() {
+				if st, ok := typeSpec.Type.(*ast.StructType); ok {
+					structType = st
+					return false
+				}
+			}
+		}
+		return true
+	})
+
+	if structType == nil {
+		return nil, nil, fmt.Errorf("could not find struct definition")
+	}
+
+	// find the position to insert the new field (end of struct fields)
+	insertPos := structType.Fields.Closing - 1
+	if insertPos == structType.Fields.Opening {
+		// struct has no fields yet
+		insertPos = structType.Fields.Closing
+	}
+
+	var buf bytes.Buffer
+	if err := fieldInfo.Emit(&buf, types.RelativeTo(fieldInfo.Named.Obj().Pkg())); err != nil {
+		return nil, nil, err
+	}
+
+	_, err = declPGF.Mapper.PosRange(declPGF.Tok, insertPos, insertPos)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	textEdit := analysis.TextEdit{
+		Pos:     insertPos,
+		End:     insertPos,
+		NewText: []byte(buf.String()),
+	}
+
+	fix := &analysis.SuggestedFix{
+		Message:   fmt.Sprintf("Add field %s to struct %s", fieldInfo.Expr.Sel.Name, fieldInfo.Named.Obj().Name()),
+		TextEdits: []analysis.TextEdit{textEdit},
+	}
+
+	return fieldInfo.Fset, fix, nil
+}