Make structFieldInfo type simpler

Author: dennypenta

gopls/internal/golang/codeaction.go

@@ -337,12 +337,16 @@ func quickFix(ctx context.Context, req *codeActionsRequest) error {
 				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.
+				// Offer a "Declare missing field T.f" code action AND "Declare missing method T.f" as specified above
 				// See [stubMissingStructFieldFixer] for command implementation.
 				fi := stubmethods.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 field might be a method
+					msg = fmt.Sprintf("Declare missing method %s.%s", fi.Named.Obj().Name(), fi.Expr.Sel.Name)
+					req.addApplyFixAction(msg, fixMissingCalledFunction, req.loc)
 				}
 			}
 

gopls/internal/golang/stub.go

@@ -204,7 +204,7 @@ func insertStructField(ctx context.Context, snapshot *cache.Snapshot, mp *metada
 	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.Object.Name() {
+			if typeSpec.Name.Name == fieldInfo.Named.Obj().Name() {
 				if st, ok := typeSpec.Type.(*ast.StructType); ok {
 					structType = st
 					return false

gopls/internal/golang/stubmethods/stubcalledfunc.go

@@ -47,7 +47,7 @@ func GetCallStubInfo(fset *token.FileSet, info *types.Info, path []ast.Node, pos
 			// 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
-			recvType, pointer := concreteType(recvExpr, info)
+			recvType, pointer := concreteType(info, recvExpr)
 
 			if recvType == nil || recvType.Obj().Pkg() == nil {
 				return nil

gopls/internal/golang/stubmethods/stubmethods.go

@@ -218,7 +218,7 @@ func fromCallExpr(fset *token.FileSet, info *types.Info, pos token.Pos, call *as
 		return nil
 	}
 
-	concType, pointer := concreteType(arg, info)
+	concType, pointer := concreteType(info, arg)
 	if concType == nil || concType.Obj().Pkg() == nil {
 		return nil
 	}
@@ -272,7 +272,7 @@ func fromReturnStmt(fset *token.FileSet, info *types.Info, pos token.Pos, path [
 		return nil, fmt.Errorf("pos %d not within return statement bounds: [%d-%d]", pos, ret.Pos(), ret.End())
 	}
 
-	concType, pointer := concreteType(ret.Results[returnIdx], info)
+	concType, pointer := concreteType(info, ret.Results[returnIdx])
 	if concType == nil || concType.Obj().Pkg() == nil {
 		return nil, nil // result is not a named or *named or alias thereof
 	}
@@ -330,7 +330,7 @@ func fromValueSpec(fset *token.FileSet, info *types.Info, spec *ast.ValueSpec, p
 		ifaceNode = call.Fun
 		rhs = call.Args[0]
 	}
-	concType, pointer := concreteType(rhs, info)
+	concType, pointer := concreteType(info, rhs)
 	if concType == nil || concType.Obj().Pkg() == nil {
 		return nil
 	}
@@ -385,7 +385,7 @@ func fromAssignStmt(fset *token.FileSet, info *types.Info, assign *ast.AssignStm
 	if ifaceObj == nil {
 		return nil
 	}
-	concType, pointer := concreteType(rhs, info)
+	concType, pointer := concreteType(info, rhs)
 	if concType == nil || concType.Obj().Pkg() == nil {
 		return nil
 	}
@@ -434,7 +434,7 @@ func ifaceObjFromType(t types.Type) *types.TypeName {
 // method will return a nil *types.Named. The second return parameter
 // is a boolean that indicates whether the concreteType was defined as a
 // pointer or value.
-func concreteType(e ast.Expr, info *types.Info) (*types.Named, bool) {
+func concreteType(info *types.Info, e ast.Expr) (*types.Named, bool) {
 	tv, ok := info.Types[e]
 	if !ok {
 		return nil, false
@@ -451,6 +451,7 @@ func concreteType(e ast.Expr, info *types.Info) (*types.Named, bool) {
 	return named, isPtr
 }
 
+// GetFieldStubInfo creates a StructFieldInfo instance to generate a struct field in a given SelectorExpr
 func GetFieldStubInfo(fset *token.FileSet, info *types.Info, path []ast.Node) *StructFieldInfo {
 	for _, node := range path {
 		s, ok := node.(*ast.SelectorExpr)
@@ -460,43 +461,25 @@ func GetFieldStubInfo(fset *token.FileSet, info *types.Info, path []ast.Node) *S
 		// 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
-		recvType, _ := concreteType(recvExpr, info)
+		recvNamed, _ := concreteType(info, recvExpr)
 
-		if recvType == nil || recvType.Obj().Pkg() == nil {
+		if recvNamed == nil || recvNamed.Obj().Pkg() == nil {
 			return nil
 		}
 
-		// A method of a function-local type cannot be stubbed
-		// since there's nowhere to put the methods.
-		recv := recvType.Obj()
-		if recv.Parent() != recv.Pkg().Scope() {
-			return nil
-		}
-
-		obj := types.Object(recv)
-		tv, ok := info.Types[s.X]
-		if !ok {
-			break
-		}
-
-		named, ok := tv.Type.(*types.Named)
-		if !ok {
-			break
-		}
-
-		structType, ok := named.Underlying().(*types.Struct)
+		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,
-			Struct: structType,
-			Named:  named,
-			Info:   info,
-			Path:   path,
-			Object: obj,
+			Fset:       fset,
+			Expr:       s,
+			Named:      recvNamed,
+			info:       info,
+			path:       path,
+			structType: structType,
 		}
 	}
 
@@ -505,13 +488,18 @@ func GetFieldStubInfo(fset *token.FileSet, info *types.Info, path []ast.Node) *S
 
 // StructFieldInfo describes f field in x.f where x has a named struct type
 type StructFieldInfo struct {
-	Fset   *token.FileSet
-	Expr   *ast.SelectorExpr
-	Struct *types.Struct
-	Named  *types.Named
-	Info   *types.Info
-	Path   []ast.Node
-	Object types.Object
+	// Fset is a file set to provide a file where the struct field is accessed
+	Fset *token.FileSet
+	// Expr is a selector expression
+	Expr *ast.SelectorExpr
+	// Named is a selected struct type
+	Named *types.Named
+
+	info *types.Info
+	// path is a node path to SelectorExpr
+	path []ast.Node
+	// structType is an underlying struct type, makes sure the receiver is a struct
+	structType *types.Struct
 }
 
 // Emit writes to out the missing field based on type info.
@@ -521,22 +509,18 @@ func (si *StructFieldInfo) Emit(out *bytes.Buffer, qual types.Qualifier) error {
 	}
 
 	// Get types from context at the selector expression position
-	typesFromContext := typesutil.TypesFromContext(si.Info, si.Path, si.Expr.Pos())
+	typesFromContext := typesutil.TypesFromContext(si.info, si.path, si.Expr.Pos())
 
-	// Default to interface{} if we couldn't determine the type from context
+	// Default to any if we couldn't determine the type from context
 	var fieldType types.Type
 	if len(typesFromContext) > 0 {
 		fieldType = typesFromContext[0]
 	} else {
-		// Create a new interface{} type
 		fieldType = types.Universe.Lookup("any").Type()
 	}
 
-	out.Write([]byte{'\n', '\t'})
-	out.WriteString(si.Expr.Sel.Name)
-	out.WriteByte(' ')
-	out.WriteString(types.TypeString(fieldType, qual))
-	if si.Struct.NumFields() == 0 {
+	fmt.Fprintf(out, "\n\t%s %s", si.Expr.Sel.Name, types.TypeString(fieldType, qual))
+	if si.structType.NumFields() == 0 {
 		out.WriteByte('\n')
 	}
 	return nil

gopls/internal/util/typesutil/typesutil.go

@@ -62,17 +62,11 @@ func TypesFromContext(info *types.Info, path []ast.Node, pos token.Pos) []types.
 
 	switch parent := parent.(type) {
 	case *ast.AssignStmt:
-		right := false
-		for _, rhs := range parent.Rhs {
-			if astutil.NodeContains(rhs, pos) {
-				right = true
-				break
-			}
-		}
+		right := pos > parent.TokPos
 		if right {
-			typs = append(typs, typeFromExprAssignExpr(parent.Rhs, parent.Lhs, info, path, pos, validType)...)
+			typs = append(typs, typeFromExprAssignExpr(parent.Rhs, parent.Lhs, info, pos, validType)...)
 		} else {
-			typs = append(typs, typeFromExprAssignExpr(parent.Lhs, parent.Rhs, info, path, pos, validType)...)
+			typs = append(typs, typeFromExprAssignExpr(parent.Lhs, parent.Rhs, info, pos, validType)...)
 		}
 	case *ast.ValueSpec:
 		if len(parent.Values) == 1 {
@@ -234,7 +228,10 @@ func EnclosingSignature(path []ast.Node, info *types.Info) *types.Signature {
 	return nil
 }
 
-func typeFromExprAssignExpr(exprs, opposites []ast.Expr, info *types.Info, path []ast.Node, pos token.Pos, validType func(t types.Type) types.Type) []types.Type {
+// typeFromExprAssignExpr extracts a type from a given expression
+// 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)
 	// Append all lhs's type
 	if len(exprs) == 1 {
@@ -250,7 +247,7 @@ func typeFromExprAssignExpr(exprs, opposites []ast.Expr, info *types.Info, path
 	}
 	// Append corresponding index of lhs's type
 	for i := range exprs {
-		if exprs[i].Pos() <= pos && pos <= exprs[i].End() {
+		if astutil.NodeContains(exprs[i], pos) {
 			t := info.TypeOf(opposites[i])
 			typs = append(typs, validType(t))
 			break