Change struct definition discovery to position based instead of a type name

Author: dennypenta

gopls/doc/features/diagnostics.md

@@ -72,7 +72,6 @@ There is an optional third source of diagnostics:
   are transitively free from errors, so optimization diagnostics
   will not be shown on packages that do not build.
 
-
 ## Recomputation of diagnostics
 
 By default, diagnostics are automatically recomputed each time the source files
@@ -278,7 +277,7 @@ func doSomething(i int) string {
 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.
+the missing field, inferring its type from the context in which it is used.
 
 Consider the following code where `Foo` does not have a field `bar`:
 

gopls/doc/release/v0.17.0.md

@@ -206,7 +206,7 @@ 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
+`Go: Generate Unit Tests For file/function/package` command which uses the
 [gotests](https://github.com/cweill/gotests) tool.
 
 ## Generate missing struct field from access

gopls/internal/golang/stub.go

@@ -198,23 +198,23 @@ func insertStructField(ctx context.Context, snapshot *cache.Snapshot, mp *metada
 	}
 
 	// 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
-	})
+	pos := fieldInfo.Named.Obj().Pos()
+	endPos := pos + token.Pos(len(fieldInfo.Named.Obj().Name()))
+	curIdent, ok := declPGF.Cursor.FindPos(pos, endPos)
+	if !ok {
+		return nil, nil, fmt.Errorf("could not find identifier at position %v-%v", pos, endPos)
+	}
 
-	if structType == nil {
-		return nil, nil, fmt.Errorf("could not find struct definition")
+	// Rest of the code remains the same
+	typeNode, ok := curIdent.NextSibling()
+	if !ok {
+		return nil, nil, fmt.Errorf("could not find type specification")
 	}
 
+	structType, ok := typeNode.Node().(*ast.StructType)
+	if !ok {
+		return nil, nil, fmt.Errorf("type at position %v is not a struct type", pos)
+	}
 	// Find metadata for the symbol's declaring package
 	// as we'll need its import mapping.
 	declMeta := findFileInDeps(snapshot, mp, declPGF.URI)
@@ -229,27 +229,24 @@ func insertStructField(ctx context.Context, snapshot *cache.Snapshot, mp *metada
 	if insertPos == structType.Fields.Opening {
 		// struct has no fields yet
 		insertPos = structType.Fields.Closing
+		_, err = declPGF.Mapper.PosRange(declPGF.Tok, insertPos, insertPos)
+		if err != nil {
+			return nil, nil, err
+		}
 	}
 
 	var buf bytes.Buffer
 	if err := fieldInfo.Emit(&buf, qual); 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: buf.Bytes(),
-	}
-
 	return fieldInfo.Fset, &analysis.SuggestedFix{
-		Message:   fmt.Sprintf("Add field %s to struct %s", fieldInfo.Expr.Sel.Name, fieldInfo.Named.Obj().Name()),
-		TextEdits: []analysis.TextEdit{textEdit},
+		Message: fmt.Sprintf("Add field %s to struct %s", fieldInfo.Expr.Sel.Name, fieldInfo.Named.Obj().Name()),
+		TextEdits: []analysis.TextEdit{{
+			Pos:     insertPos,
+			End:     insertPos,
+			NewText: buf.Bytes(),
+		}},
 	}, nil
 }
 

gopls/internal/golang/stubmethods/stubmethods.go

@@ -458,36 +458,35 @@ func concreteType(info *types.Info, e ast.Expr) (*types.Named, bool) {
 	return named, isPtr
 }
 
-// GetFieldStubInfo creates a StructFieldInfo instance to generate a struct field in a given SelectorExpr
+// GetFieldStubInfo finds innermost enclosing selector x.f where x is a named struct type or a pointer to a struct type.
 func GetFieldStubInfo(fset *token.FileSet, info *types.Info, pgf *parsego.File, start, end token.Pos) *StructFieldInfo {
 	path, _ := astutil.PathEnclosingInterval(pgf.File, start, end)
 	for _, node := range path {
 		s, ok := node.(*ast.SelectorExpr)
-		if !ok {
-			continue
-		}
-		// If recvExpr is a package name, compiler error would be
-		// e.g., "undefined: http.bar", thus will not hit this code path.
-		recvExpr := s.X
-		recvNamed, _ := concreteType(info, recvExpr)
+		if ok {
+			// If recvExpr is a package name, compiler error would be
+			// e.g., "undefined: http.bar", thus will not hit this code path.
+			recvExpr := s.X
+			recvNamed, _ := concreteType(info, recvExpr)
 
-		if recvNamed == nil || recvNamed.Obj().Pkg() == nil {
-			return nil
-		}
+			if recvNamed == nil || recvNamed.Obj().Pkg() == nil {
+				return nil
+			}
 
-		structType, ok := recvNamed.Underlying().(*types.Struct)
-		if !ok {
-			break
-		}
+			structType, ok := recvNamed.Underlying().(*types.Struct)
+			if !ok {
+				break
+			}
 
-		// Have: x.f where x has a named struct type.
-		return &StructFieldInfo{
-			Fset:       fset,
-			Expr:       s,
-			Named:      recvNamed,
-			info:       info,
-			path:       path,
-			structType: structType,
+			// Have: x.f where x has a named struct type.
+			return &StructFieldInfo{
+				Fset:       fset,
+				Expr:       s,
+				Named:      recvNamed,
+				info:       info,
+				path:       path,
+				structType: structType,
+			}
 		}
 	}
 

gopls/internal/util/typesutil/typesutil.go

@@ -65,11 +65,11 @@ func TypesFromContext(info *types.Info, path []ast.Node, pos token.Pos) []types.
 	switch parent := parent.(type) {
 	case *ast.AssignStmt:
 		right := pos > parent.TokPos
+		expr, opposites := parent.Lhs, parent.Rhs
 		if right {
-			typs = append(typs, typeFromExprAssignExpr(parent.Rhs, parent.Lhs, info, pos, validType)...)
-		} else {
-			typs = append(typs, typeFromExprAssignExpr(parent.Lhs, parent.Rhs, info, pos, validType)...)
+			expr, opposites = opposites, expr
 		}
+		typs = append(typs, typeFromExprAssignExpr(expr, opposites, info, pos, validType)...)
 	case *ast.ValueSpec:
 		if len(parent.Values) == 1 {
 			for _, lhs := range parent.Names {
@@ -234,7 +234,7 @@ func EnclosingSignature(path []ast.Node, info *types.Info) *types.Signature {
 // f.x = v
 // where v - a value which type the function extracts
 func typeFromExprAssignExpr(exprs, opposites []ast.Expr, info *types.Info, pos token.Pos, validType func(t types.Type) types.Type) []types.Type {
-	typs := make([]types.Type, 0)
+	var typs []types.Type
 	// Append all lhs's type
 	if len(exprs) == 1 {
 		for i := range opposites {
@@ -245,16 +245,15 @@ func typeFromExprAssignExpr(exprs, opposites []ast.Expr, info *types.Info, pos t
 	}
 	// Lhs and Rhs counts do not match, give up
 	if len(opposites) != len(exprs) {
-		return typs
+		return nil
 	}
 	// Append corresponding index of lhs's type
 	for i := range exprs {
 		if astutil.NodeContains(exprs[i], pos) {
 			t := info.TypeOf(opposites[i])
-			typs = append(typs, validType(t))
-			break
+			return []types.Type{validType(t)}
 		}
 	}
 
-	return typs
+	return nil
 }