diff --git a/gopls/doc/features/diagnostics.md b/gopls/doc/features/diagnostics.md
index 8c9305c94b6..5955a55d8b3 100644
--- a/gopls/doc/features/diagnostics.md
+++ b/gopls/doc/features/diagnostics.md
@@ -127,7 +127,7 @@ Client support:
 <!-- Below we list any quick fixes (by their internal fix name)
      that aren't analyzers. -->
 
-### `stubMethods`: Declare missing methods of type
+### `stubMissingInterfaceMethods`: Declare missing methods of I
 
 When a value of a concrete type is assigned to a variable of an
 interface type, but the concrete type does not possess all the
@@ -169,6 +169,34 @@ position.
 client there, or a progress notification indicating that something
 happened.)
 
+### `StubMissingCalledFunction`: Declare missing method T.f
+
+When you attempt to call a method on a type that does not have that method,
+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 method, inferring its type from the call.
+
+Consider the following code where `Foo` does not have a method `bar`:
+
+```go
+type Foo struct{}
+
+func main() {
+  var s string
+  f := Foo{}
+  s = f.bar("str", 42) // error: f.bar undefined (type Foo has no field or method bar)
+}
+```
+
+Gopls will offer a quick fix, "Declare missing method Foo.bar".
+When invoked, it creates the following declaration:
+
+```go
+func (f Foo) bar(s string, i int) string {
+	panic("unimplemented")
+}
+```
+
 <!--
 
 dorky details and deletia:
diff --git a/gopls/doc/release/v0.17.0.md b/gopls/doc/release/v0.17.0.md
index 3f4f7458223..5b26cea525d 100644
--- a/gopls/doc/release/v0.17.0.md
+++ b/gopls/doc/release/v0.17.0.md
@@ -63,3 +63,12 @@ function's Go `func` declaration. If the function is implemented in C
 or assembly, the function has no body. Executing a second Definition
 query (while already at the Go declaration) will navigate you to the
 assembly implementation.
+
+## Generate missing method from function call
+
+When you attempt to call a method on a type that does not have that method,
+the compiler will report an error like “type X has no field or method Y”.
+Gopls now offers a new code action, “Declare missing method of T.f”,
+where T is the concrete type and f is the undefined method.
+The stub method's signature is inferred
+from the context of the call.
diff --git a/gopls/internal/golang/codeaction.go b/gopls/internal/golang/codeaction.go
index 3c916628a1a..844f5dfe46c 100644
--- a/gopls/internal/golang/codeaction.go
+++ b/gopls/internal/golang/codeaction.go
@@ -301,20 +301,32 @@ func quickFix(ctx context.Context, req *codeActionsRequest) error {
 			continue
 		}
 
+		msg := typeError.Error()
+		switch {
 		// "Missing method" error? (stubmethods)
 		// Offer a "Declare missing methods of INTERFACE" code action.
-		// See [stubMethodsFixer] for command implementation.
-		msg := typeError.Error()
-		if strings.Contains(msg, "missing method") ||
-			strings.HasPrefix(msg, "cannot convert") ||
-			strings.Contains(msg, "not implement") {
+		// See [stubMissingInterfaceMethodsFixer] for command implementation.
+		case strings.Contains(msg, "missing method"),
+			strings.HasPrefix(msg, "cannot convert"),
+			strings.Contains(msg, "not implement"):
 			path, _ := astutil.PathEnclosingInterval(req.pgf.File, start, end)
-			si := stubmethods.GetStubInfo(req.pkg.FileSet(), info, path, start)
+			si := stubmethods.GetIfaceStubInfo(req.pkg.FileSet(), info, path, start)
 			if si != nil {
 				qf := typesutil.FileQualifier(req.pgf.File, si.Concrete.Obj().Pkg(), info)
 				iface := types.TypeString(si.Interface.Type(), qf)
 				msg := fmt.Sprintf("Declare missing methods of %s", iface)
-				req.addApplyFixAction(msg, fixStubMethods, req.loc)
+				req.addApplyFixAction(msg, fixMissingInterfaceMethods, req.loc)
+			}
+
+		// "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)
+			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)
 			}
 		}
 	}
diff --git a/gopls/internal/golang/completion/format.go b/gopls/internal/golang/completion/format.go
index c52ce94698e..45d734efbfe 100644
--- a/gopls/internal/golang/completion/format.go
+++ b/gopls/internal/golang/completion/format.go
@@ -17,6 +17,7 @@ import (
 	"golang.org/x/tools/gopls/internal/golang/completion/snippet"
 	"golang.org/x/tools/gopls/internal/protocol"
 	"golang.org/x/tools/gopls/internal/util/safetoken"
+	"golang.org/x/tools/gopls/internal/util/typesutil"
 	"golang.org/x/tools/internal/event"
 	"golang.org/x/tools/internal/imports"
 	"golang.org/x/tools/internal/typesinternal"
@@ -62,7 +63,7 @@ func (c *completer) item(ctx context.Context, cand candidate) (CompletionItem, e
 	if isTypeName(obj) && c.wantTypeParams() {
 		// obj is a *types.TypeName, so its type must be Alias|Named.
 		tparams := typesinternal.TypeParams(obj.Type().(typesinternal.NamedOrAlias))
-		label += golang.FormatTypeParams(tparams)
+		label += typesutil.FormatTypeParams(tparams)
 		insert = label // maintain invariant above (label == insert)
 	}
 
diff --git a/gopls/internal/golang/fix.go b/gopls/internal/golang/fix.go
index 7c44aa4d273..119ca390ced 100644
--- a/gopls/internal/golang/fix.go
+++ b/gopls/internal/golang/fix.go
@@ -58,14 +58,15 @@ func singleFile(fixer1 singleFileFixer) fixer {
 
 // Names of ApplyFix.Fix created directly by the CodeAction handler.
 const (
-	fixExtractVariable   = "extract_variable"
-	fixExtractFunction   = "extract_function"
-	fixExtractMethod     = "extract_method"
-	fixInlineCall        = "inline_call"
-	fixInvertIfCondition = "invert_if_condition"
-	fixSplitLines        = "split_lines"
-	fixJoinLines         = "join_lines"
-	fixStubMethods       = "stub_methods"
+	fixExtractVariable         = "extract_variable"
+	fixExtractFunction         = "extract_function"
+	fixExtractMethod           = "extract_method"
+	fixInlineCall              = "inline_call"
+	fixInvertIfCondition       = "invert_if_condition"
+	fixSplitLines              = "split_lines"
+	fixJoinLines               = "join_lines"
+	fixMissingInterfaceMethods = "stub_missing_interface_method"
+	fixMissingCalledFunction   = "stub_missing_called_function"
 )
 
 // ApplyFix applies the specified kind of suggested fix to the given
@@ -102,14 +103,15 @@ func ApplyFix(ctx context.Context, fix string, snapshot *cache.Snapshot, fh file
 
 		// Ad-hoc fixers: these are used when the command is
 		// constructed directly by logic in server/code_action.
-		fixExtractFunction:   singleFile(extractFunction),
-		fixExtractMethod:     singleFile(extractMethod),
-		fixExtractVariable:   singleFile(extractVariable),
-		fixInlineCall:        inlineCall,
-		fixInvertIfCondition: singleFile(invertIfCondition),
-		fixSplitLines:        singleFile(splitLines),
-		fixJoinLines:         singleFile(joinLines),
-		fixStubMethods:       stubMethodsFixer,
+		fixExtractFunction:         singleFile(extractFunction),
+		fixExtractMethod:           singleFile(extractMethod),
+		fixExtractVariable:         singleFile(extractVariable),
+		fixInlineCall:              inlineCall,
+		fixInvertIfCondition:       singleFile(invertIfCondition),
+		fixSplitLines:              singleFile(splitLines),
+		fixJoinLines:               singleFile(joinLines),
+		fixMissingInterfaceMethods: stubMissingInterfaceMethodsFixer,
+		fixMissingCalledFunction:   stubMissingCalledFunctionFixer,
 	}
 	fixer, ok := fixers[fix]
 	if !ok {
diff --git a/gopls/internal/golang/stub.go b/gopls/internal/golang/stub.go
index 1a4186cf372..106963a9c55 100644
--- a/gopls/internal/golang/stub.go
+++ b/gopls/internal/golang/stub.go
@@ -12,7 +12,6 @@ import (
 	"go/parser"
 	"go/token"
 	"go/types"
-	"io"
 	pathpkg "path"
 	"strings"
 
@@ -26,104 +25,62 @@ import (
 	"golang.org/x/tools/gopls/internal/util/safetoken"
 	"golang.org/x/tools/internal/diff"
 	"golang.org/x/tools/internal/tokeninternal"
-	"golang.org/x/tools/internal/typesinternal"
 )
 
-// stubMethodsFixer returns a suggested fix to declare the missing
+// stubMissingInterfaceMethodsFixer returns a suggested fix to declare the missing
 // methods of the concrete type that is assigned to an interface type
 // at the cursor position.
-func stubMethodsFixer(ctx context.Context, snapshot *cache.Snapshot, pkg *cache.Package, pgf *parsego.File, start, end token.Pos) (*token.FileSet, *analysis.SuggestedFix, error) {
+func stubMissingInterfaceMethodsFixer(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)
-	si := stubmethods.GetStubInfo(pkg.FileSet(), pkg.TypesInfo(), nodes, start)
+	si := stubmethods.GetIfaceStubInfo(pkg.FileSet(), pkg.TypesInfo(), nodes, start)
 	if si == nil {
 		return nil, nil, fmt.Errorf("nil interface request")
 	}
+	return insertDeclsAfter(ctx, snapshot, pkg.Metadata(), si.Fset, si.Concrete.Obj(), si.Emit)
+}
 
-	// A function-local type cannot be stubbed
-	// since there's nowhere to put the methods.
-	// TODO(adonovan): move this check into GetStubInfo instead of offering a bad fix.
-	conc := si.Concrete.Obj()
-	if conc.Parent() != conc.Pkg().Scope() {
-		return nil, nil, fmt.Errorf("local type %q cannot be stubbed", conc.Name())
+// stubMissingCalledFunctionFixer returns a suggested fix to declare the missing
+// method that the user may want to generate based on CallExpr
+// at the cursor position.
+func stubMissingCalledFunctionFixer(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)
+	si := stubmethods.GetCallStubInfo(pkg.FileSet(), pkg.TypesInfo(), nodes, start)
+	if si == nil {
+		return nil, nil, fmt.Errorf("invalid type request")
 	}
+	return insertDeclsAfter(ctx, snapshot, pkg.Metadata(), si.Fset, si.Receiver.Obj(), si.Emit)
+}
 
-	// Parse the file declaring the concrete type.
+// 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.
+type emitter = func(out *bytes.Buffer, qual types.Qualifier) error
+
+// insertDeclsAfter locates the file that declares symbol sym,
+// (which must be among the dependencies of mp),
+// calls the emit function to generate new declarations,
+// respecting the local import environment,
+// and splices those declarations into the file after the declaration of sym,
+// updating imports as needed.
+//
+// fset must provide the position of sym.
+func insertDeclsAfter(ctx context.Context, snapshot *cache.Snapshot, mp *metadata.Package, fset *token.FileSet, sym types.Object, emit emitter) (*token.FileSet, *analysis.SuggestedFix, error) {
+	// Parse the file declaring the sym.
 	//
 	// Beware: declPGF is not necessarily covered by pkg.FileSet() or si.Fset.
-	declPGF, _, err := parseFull(ctx, snapshot, si.Fset, conc.Pos())
+	declPGF, _, err := parseFull(ctx, snapshot, fset, sym.Pos())
 	if err != nil {
-		return nil, nil, fmt.Errorf("failed to parse file %q declaring implementation type: %w", declPGF.URI, err)
+		return nil, nil, fmt.Errorf("failed to parse file %q declaring implementation symbol: %w", declPGF.URI, err)
 	}
 	if declPGF.Fixed() {
 		return nil, nil, fmt.Errorf("file contains parse errors: %s", declPGF.URI)
 	}
 
-	// Find metadata for the concrete type's declaring package
+	// Find metadata for the symbol's declaring package
 	// as we'll need its import mapping.
-	declMeta := findFileInDeps(snapshot, pkg.Metadata(), declPGF.URI)
+	declMeta := findFileInDeps(snapshot, mp, declPGF.URI)
 	if declMeta == nil {
-		return nil, nil, bug.Errorf("can't find metadata for file %s among dependencies of %s", declPGF.URI, pkg)
-	}
-
-	// Record all direct methods of the current object
-	concreteFuncs := make(map[string]struct{})
-	if named, ok := types.Unalias(si.Concrete).(*types.Named); ok {
-		for i := 0; i < named.NumMethods(); i++ {
-			concreteFuncs[named.Method(i).Name()] = struct{}{}
-		}
-	}
-
-	// Find subset of interface methods that the concrete type lacks.
-	ifaceType := si.Interface.Type().Underlying().(*types.Interface)
-
-	type missingFn struct {
-		fn         *types.Func
-		needSubtle string
-	}
-
-	var (
-		missing                  []missingFn
-		concreteStruct, isStruct = typesinternal.Origin(si.Concrete).Underlying().(*types.Struct)
-	)
-
-	for i := 0; i < ifaceType.NumMethods(); i++ {
-		imethod := ifaceType.Method(i)
-		cmethod, index, _ := types.LookupFieldOrMethod(si.Concrete, si.Pointer, imethod.Pkg(), imethod.Name())
-		if cmethod == nil {
-			missing = append(missing, missingFn{fn: imethod})
-			continue
-		}
-
-		if _, ok := cmethod.(*types.Var); ok {
-			// len(LookupFieldOrMethod.index) = 1 => conflict, >1 => shadow.
-			return nil, nil, fmt.Errorf("adding method %s.%s would conflict with (or shadow) existing field",
-				conc.Name(), imethod.Name())
-		}
-
-		if _, exist := concreteFuncs[imethod.Name()]; exist {
-			if !types.Identical(cmethod.Type(), imethod.Type()) {
-				return nil, nil, fmt.Errorf("method %s.%s already exists but has the wrong type: got %s, want %s",
-					conc.Name(), imethod.Name(), cmethod.Type(), imethod.Type())
-			}
-			continue
-		}
-
-		mf := missingFn{fn: imethod}
-		if isStruct && len(index) > 0 {
-			field := concreteStruct.Field(index[0])
-
-			fn := field.Name()
-			if is[*types.Pointer](field.Type()) {
-				fn = "*" + fn
-			}
-
-			mf.needSubtle = fmt.Sprintf("// Subtle: this method shadows the method (%s).%s of %s.%s.\n", fn, imethod.Name(), si.Concrete.Obj().Name(), field.Name())
-		}
-
-		missing = append(missing, mf)
-	}
-	if len(missing) == 0 {
-		return nil, nil, fmt.Errorf("no missing methods found")
+		return nil, nil, bug.Errorf("can't find metadata for file %s among dependencies of %s", declPGF.URI, mp)
 	}
 
 	// Build import environment for the declaring file.
@@ -170,7 +127,7 @@ func stubMethodsFixer(ctx context.Context, snapshot *cache.Snapshot, pkg *cache.
 		// TODO(adonovan): don't ignore vendor prefix.
 		//
 		// Ignore the current package import.
-		if pkg.Path() == conc.Pkg().Path() {
+		if pkg.Path() == sym.Pkg().Path() {
 			return ""
 		}
 
@@ -181,7 +138,7 @@ func stubMethodsFixer(ctx context.Context, snapshot *cache.Snapshot, pkg *cache.
 			//
 			// TODO(adonovan): resolve conflict between declared
 			// name and existing file-level (declPGF.File.Imports)
-			// or package-level (si.Concrete.Pkg.Scope) decls by
+			// or package-level (sym.Pkg.Scope) decls by
 			// generating a fresh name.
 			name = pkg.Name()
 			importEnv[importPath] = name
@@ -196,73 +153,13 @@ func stubMethodsFixer(ctx context.Context, snapshot *cache.Snapshot, pkg *cache.
 		return name
 	}
 
-	// Format interface name (used only in a comment).
-	iface := si.Interface.Name()
-	if ipkg := si.Interface.Pkg(); ipkg != nil && ipkg != conc.Pkg() {
-		iface = ipkg.Name() + "." + iface
-	}
-
-	// Pointer receiver?
-	var star string
-	if si.Pointer {
-		star = "*"
-	}
-
-	// If there are any that have named receiver, choose the first one.
-	// Otherwise, use lowercase for the first letter of the object.
-	rn := strings.ToLower(si.Concrete.Obj().Name()[0:1])
-	if named, ok := types.Unalias(si.Concrete).(*types.Named); ok {
-		for i := 0; i < named.NumMethods(); i++ {
-			if recv := named.Method(i).Type().(*types.Signature).Recv(); recv.Name() != "" {
-				rn = recv.Name()
-				break
-			}
-		}
-	}
-
-	// Check for receiver name conflicts
-	checkRecvName := func(tuple *types.Tuple) bool {
-		for i := 0; i < tuple.Len(); i++ {
-			if rn == tuple.At(i).Name() {
-				return true
-			}
-		}
-		return false
-	}
-
-	// Format the new methods.
-	var newMethods bytes.Buffer
-
-	for index := range missing {
-		mrn := rn + " "
-		sig := missing[index].fn.Signature()
-		if checkRecvName(sig.Params()) || checkRecvName(sig.Results()) {
-			mrn = ""
-		}
-
-		fmt.Fprintf(&newMethods, `// %s implements %s.
-%sfunc (%s%s%s%s) %s%s {
-	panic("unimplemented")
-}
-`,
-			missing[index].fn.Name(),
-			iface,
-			missing[index].needSubtle,
-			mrn,
-			star,
-			si.Concrete.Obj().Name(),
-			FormatTypeParams(typesinternal.TypeParams(si.Concrete)),
-			missing[index].fn.Name(),
-			strings.TrimPrefix(types.TypeString(missing[index].fn.Type(), qual), "func"))
-	}
-
-	// Compute insertion point for new methods:
+	// Compute insertion point for new declarations:
 	// after the top-level declaration enclosing the (package-level) type.
 	insertOffset, err := safetoken.Offset(declPGF.Tok, declPGF.File.End())
 	if err != nil {
 		return nil, nil, bug.Errorf("internal error: end position outside file bounds: %v", err)
 	}
-	concOffset, err := safetoken.Offset(si.Fset.File(conc.Pos()), conc.Pos())
+	symOffset, err := safetoken.Offset(fset.File(sym.Pos()), sym.Pos())
 	if err != nil {
 		return nil, nil, bug.Errorf("internal error: finding type decl offset: %v", err)
 	}
@@ -271,22 +168,25 @@ func stubMethodsFixer(ctx context.Context, snapshot *cache.Snapshot, pkg *cache.
 		if err != nil {
 			return nil, nil, bug.Errorf("internal error: finding decl offset: %v", err)
 		}
-		if declEndOffset > concOffset {
+		if declEndOffset > symOffset {
 			insertOffset = declEndOffset
 			break
 		}
 	}
 
-	// Splice the new methods into the file content.
+	// Splice the new declarations into the file content.
 	var buf bytes.Buffer
 	input := declPGF.Mapper.Content // unfixed content of file
 	buf.Write(input[:insertOffset])
 	buf.WriteByte('\n')
-	io.Copy(&buf, &newMethods)
+	err = emit(&buf, qual)
+	if err != nil {
+		return nil, nil, err
+	}
 	buf.Write(input[insertOffset:])
 
 	// Re-parse the file.
-	fset := token.NewFileSet()
+	fset = token.NewFileSet()
 	newF, err := parser.ParseFile(fset, declPGF.URI.Path(), buf.Bytes(), parser.ParseComments|parser.SkipObjectResolution)
 	if err != nil {
 		return nil, nil, fmt.Errorf("could not reparse file: %w", err)
diff --git a/gopls/internal/golang/stubmethods/stubcalledfunc.go b/gopls/internal/golang/stubmethods/stubcalledfunc.go
new file mode 100644
index 00000000000..c8136627c44
--- /dev/null
+++ b/gopls/internal/golang/stubmethods/stubcalledfunc.go
@@ -0,0 +1,352 @@
+// 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.
+
+package stubmethods
+
+import (
+	"bytes"
+	"fmt"
+	"go/ast"
+	"go/token"
+	"go/types"
+	"strings"
+	"unicode"
+
+	"golang.org/x/tools/gopls/internal/util/typesutil"
+	"golang.org/x/tools/internal/typesinternal"
+)
+
+var anyType = types.Universe.Lookup("any").Type()
+
+// CallStubInfo represents a missing method
+// that a receiver type is about to generate
+// which has "type X has no field or method Y" error
+type CallStubInfo struct {
+	Fset       *token.FileSet             // the FileSet used to type-check the types below
+	Receiver   typesinternal.NamedOrAlias // the method's receiver type
+	MethodName string
+	pointer    bool
+	info       *types.Info
+	path       []ast.Node // path enclosing the CallExpr
+}
+
+// GetCallStubInfo extracts necessary information to generate a method definition from
+// a CallExpr.
+func GetCallStubInfo(fset *token.FileSet, info *types.Info, path []ast.Node, pos token.Pos) *CallStubInfo {
+	for i, n := range path {
+		switch n := n.(type) {
+		case *ast.CallExpr:
+			s, ok := n.Fun.(*ast.SelectorExpr)
+			// TODO: support generating stub functions in the same way.
+			if !ok {
+				return nil
+			}
+
+			// 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)
+
+			if recvType == nil || recvType.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
+			}
+			return &CallStubInfo{
+				Fset:       fset,
+				Receiver:   recvType,
+				MethodName: s.Sel.Name,
+				pointer:    pointer,
+				path:       path[i:],
+				info:       info,
+			}
+		}
+	}
+	return nil
+}
+
+// Emit writes to out the missing method based on type info of si.Receiver and CallExpr.
+func (si *CallStubInfo) Emit(out *bytes.Buffer, qual types.Qualifier) error {
+	params := si.collectParams()
+	rets := typesFromContext(si.info, si.path, si.path[0].Pos())
+	recv := si.Receiver.Obj()
+	// Pointer receiver?
+	var star string
+	if si.pointer {
+		star = "*"
+	}
+
+	// Choose receiver name.
+	// If any method has a named receiver, choose the first one.
+	// Otherwise, use lowercase for the first letter of the object.
+	recvName := strings.ToLower(fmt.Sprintf("%.1s", recv.Name()))
+	if named, ok := types.Unalias(si.Receiver).(*types.Named); ok {
+		for i := 0; i < named.NumMethods(); i++ {
+			if recv := named.Method(i).Type().(*types.Signature).Recv(); recv.Name() != "" {
+				recvName = recv.Name()
+				break
+			}
+		}
+	}
+
+	// Emit method declaration.
+	fmt.Fprintf(out, "\nfunc (%s %s%s%s) %s",
+		recvName,
+		star,
+		recv.Name(),
+		typesutil.FormatTypeParams(typesinternal.TypeParams(si.Receiver)),
+		si.MethodName)
+
+	// Emit parameters, avoiding name conflicts.
+	seen := map[string]bool{recvName: true}
+	out.WriteString("(")
+	for i, param := range params {
+		name := param.name
+		if seen[name] {
+			name = fmt.Sprintf("param%d", i+1)
+		}
+		seen[name] = true
+
+		if i > 0 {
+			out.WriteString(", ")
+		}
+		fmt.Fprintf(out, "%s %s", name, types.TypeString(param.typ, qual))
+	}
+	out.WriteString(") ")
+
+	// Emit result types.
+	if len(rets) > 1 {
+		out.WriteString("(")
+	}
+	for i, r := range rets {
+		if i > 0 {
+			out.WriteString(", ")
+		}
+		out.WriteString(types.TypeString(r, qual))
+	}
+	if len(rets) > 1 {
+		out.WriteString(")")
+	}
+
+	// Emit body.
+	out.WriteString(` {
+		panic("unimplemented")
+}`)
+	return nil
+}
+
+type param struct {
+	name string
+	typ  types.Type // the type of param, inferred from CallExpr
+}
+
+// collectParams gathers the parameter information needed to generate a method stub.
+// The param's type default to any if there is a type error in the argument.
+func (si *CallStubInfo) collectParams() []param {
+	var params []param
+	appendParam := func(e ast.Expr, t types.Type) {
+		p := param{"param", anyType}
+		if t != nil && !containsInvalid(t) {
+			t = types.Default(t)
+			p = param{paramName(e, t), t}
+		}
+		params = append(params, p)
+	}
+
+	args := si.path[0].(*ast.CallExpr).Args
+	for _, arg := range args {
+		t := si.info.TypeOf(arg)
+		switch t := t.(type) {
+		// This is the case where another function call returning multiple
+		// results is used as an argument.
+		case *types.Tuple:
+			for ti := 0; ti < t.Len(); ti++ {
+				appendParam(arg, t.At(ti).Type())
+			}
+		default:
+			appendParam(arg, t)
+		}
+	}
+	return params
+}
+
+// typesFromContext returns the type (or perhaps zero or multiple types)
+// of the "hole" into which the expression identified by path must fit.
+//
+// For example, given
+//
+//	s, i := "", 0
+//	s, i = EXPR
+//
+// the hole that must be filled by EXPR has type (string, int).
+//
+// It returns nil on failure.
+func typesFromContext(info *types.Info, path []ast.Node, pos token.Pos) []types.Type {
+	var typs []types.Type
+	parent := parentNode(path)
+	if parent == nil {
+		return nil
+	}
+	switch parent := parent.(type) {
+	case *ast.AssignStmt:
+		// Append all lhs's type
+		if len(parent.Rhs) == 1 {
+			for _, lhs := range parent.Lhs {
+				t := info.TypeOf(lhs)
+				if t != nil && !containsInvalid(t) {
+					t = types.Default(t)
+				} else {
+					t = anyType
+				}
+				typs = append(typs, t)
+			}
+			break
+		}
+
+		// Lhs and Rhs counts do not match, give up
+		if len(parent.Lhs) != len(parent.Rhs) {
+			break
+		}
+
+		// Append corresponding index of lhs's type
+		for i, rhs := range parent.Rhs {
+			if rhs.Pos() <= pos && pos <= rhs.End() {
+				t := info.TypeOf(parent.Lhs[i])
+				if t != nil && !containsInvalid(t) {
+					t = types.Default(t)
+				} else {
+					t = anyType
+				}
+				typs = append(typs, t)
+				break
+			}
+		}
+	case *ast.CallExpr:
+		// Find argument containing pos.
+		argIdx := -1
+		for i, callArg := range parent.Args {
+			if callArg.Pos() <= pos && pos <= callArg.End() {
+				argIdx = i
+				break
+			}
+		}
+		if argIdx == -1 {
+			break
+		}
+
+		t := info.TypeOf(parent.Fun)
+		if t == nil {
+			break
+		}
+
+		if sig, ok := t.Underlying().(*types.Signature); ok {
+			var paramType types.Type
+			if sig.Variadic() && argIdx >= sig.Params().Len()-1 {
+				v := sig.Params().At(sig.Params().Len() - 1)
+				if s, _ := v.Type().(*types.Slice); s != nil {
+					paramType = s.Elem()
+				}
+			} else if argIdx < sig.Params().Len() {
+				paramType = sig.Params().At(argIdx).Type()
+			} else {
+				break
+			}
+			if paramType == nil || containsInvalid(paramType) {
+				paramType = anyType
+			}
+			typs = append(typs, paramType)
+		}
+	default:
+		// TODO: support other common kinds of "holes", e.g.
+		//   x + EXPR         => typeof(x)
+		//   !EXPR            => bool
+		//   var x int = EXPR => int
+		//   etc.
+	}
+	return typs
+}
+
+// parentNode returns the nodes immediately enclosing path[0],
+// ignoring parens.
+func parentNode(path []ast.Node) ast.Node {
+	if len(path) <= 1 {
+		return nil
+	}
+	for _, n := range path[1:] {
+		if _, ok := n.(*ast.ParenExpr); !ok {
+			return n
+		}
+	}
+	return nil
+}
+
+// containsInvalid checks if the type name contains "invalid type",
+// which is not a valid syntax to generate.
+func containsInvalid(t types.Type) bool {
+	typeString := types.TypeString(t, nil)
+	return strings.Contains(typeString, types.Typ[types.Invalid].String())
+}
+
+// paramName heuristically chooses a parameter name from
+// its argument expression and type. Caller should ensure
+// typ is non-nil.
+func paramName(e ast.Expr, typ types.Type) string {
+	if typ == types.Universe.Lookup("error").Type() {
+		return "err"
+	}
+	switch t := e.(type) {
+	// Use the identifier's name as the argument name.
+	case *ast.Ident:
+		return t.Name
+	// Use the Sel.Name's last section as the argument name.
+	case *ast.SelectorExpr:
+		return lastSection(t.Sel.Name)
+	}
+
+	typ = typesinternal.Unpointer(typ)
+	switch t := typ.(type) {
+	// Use the first character of the type name as the argument name for builtin types
+	case *types.Basic:
+		return t.Name()[:1]
+	case *types.Slice:
+		return paramName(e, t.Elem())
+	case *types.Array:
+		return paramName(e, t.Elem())
+	case *types.Signature:
+		return "f"
+	case *types.Map:
+		return "m"
+	case *types.Chan:
+		return "ch"
+	case *types.Named:
+		return lastSection(t.Obj().Name())
+	default:
+		return lastSection(t.String())
+	}
+}
+
+// lastSection find the position of the last uppercase letter,
+// extract the substring from that point onward,
+// and convert it to lowercase.
+//
+// Example: lastSection("registryManagerFactory") = "factory"
+func lastSection(identName string) string {
+	lastUpperIndex := -1
+	for i, r := range identName {
+		if unicode.IsUpper(r) {
+			lastUpperIndex = i
+		}
+	}
+	if lastUpperIndex != -1 {
+		last := identName[lastUpperIndex:]
+		return strings.ToLower(last)
+	} else {
+		return identName
+	}
+}
diff --git a/gopls/internal/golang/stubmethods/stubmethods.go b/gopls/internal/golang/stubmethods/stubmethods.go
index b5799861251..dbfcefd9e16 100644
--- a/gopls/internal/golang/stubmethods/stubmethods.go
+++ b/gopls/internal/golang/stubmethods/stubmethods.go
@@ -8,20 +8,23 @@
 package stubmethods
 
 import (
+	"bytes"
 	"fmt"
 	"go/ast"
 	"go/token"
 	"go/types"
-
 	"golang.org/x/tools/internal/typesinternal"
+	"strings"
+
+	"golang.org/x/tools/gopls/internal/util/typesutil"
 )
 
 // TODO(adonovan): eliminate the confusing Fset parameter; only the
 // file name and byte offset of Concrete are needed.
 
-// StubInfo represents a concrete type
+// IfaceStubInfo represents a concrete type
 // that wants to stub out an interface type
-type StubInfo struct {
+type IfaceStubInfo struct {
 	// Interface is the interface that the client wants to implement.
 	// When the interface is defined, the underlying object will be a TypeName.
 	// Note that we keep track of types.Object instead of types.Type in order
@@ -32,10 +35,10 @@ type StubInfo struct {
 	Fset      *token.FileSet // the FileSet used to type-check the types below
 	Interface *types.TypeName
 	Concrete  typesinternal.NamedOrAlias
-	Pointer   bool
+	pointer   bool
 }
 
-// GetStubInfo determines whether the "missing method error"
+// GetIfaceStubInfo determines whether the "missing method error"
 // can be used to deduced what the concrete and interface types are.
 //
 // TODO(adonovan): this function (and its following 5 helpers) tries
@@ -44,7 +47,7 @@ type StubInfo struct {
 // function call. This is essentially what the refactor/satisfy does,
 // more generally. Refactor to share logic, after auditing 'satisfy'
 // for safety on ill-typed code.
-func GetStubInfo(fset *token.FileSet, info *types.Info, path []ast.Node, pos token.Pos) *StubInfo {
+func GetIfaceStubInfo(fset *token.FileSet, info *types.Info, path []ast.Node, pos token.Pos) *IfaceStubInfo {
 	for _, n := range path {
 		switch n := n.(type) {
 		case *ast.ValueSpec:
@@ -72,10 +75,133 @@ func GetStubInfo(fset *token.FileSet, info *types.Info, path []ast.Node, pos tok
 	return nil
 }
 
+// Emit writes to out the missing methods of si.Concrete required for it to implement si.Interface
+func (si *IfaceStubInfo) Emit(out *bytes.Buffer, qual types.Qualifier) error {
+	conc := si.Concrete.Obj()
+	// Record all direct methods of the current object
+	concreteFuncs := make(map[string]struct{})
+	if named, ok := types.Unalias(si.Concrete).(*types.Named); ok {
+		for i := 0; i < named.NumMethods(); i++ {
+			concreteFuncs[named.Method(i).Name()] = struct{}{}
+		}
+	}
+
+	// Find subset of interface methods that the concrete type lacks.
+	ifaceType := si.Interface.Type().Underlying().(*types.Interface)
+
+	type missingFn struct {
+		fn         *types.Func
+		needSubtle string
+	}
+
+	var (
+		missing                  []missingFn
+		concreteStruct, isStruct = typesinternal.Origin(si.Concrete).Underlying().(*types.Struct)
+	)
+
+	for i := 0; i < ifaceType.NumMethods(); i++ {
+		imethod := ifaceType.Method(i)
+		cmethod, index, _ := types.LookupFieldOrMethod(si.Concrete, si.pointer, imethod.Pkg(), imethod.Name())
+		if cmethod == nil {
+			missing = append(missing, missingFn{fn: imethod})
+			continue
+		}
+
+		if _, ok := cmethod.(*types.Var); ok {
+			// len(LookupFieldOrMethod.index) = 1 => conflict, >1 => shadow.
+			return fmt.Errorf("adding method %s.%s would conflict with (or shadow) existing field",
+				conc.Name(), imethod.Name())
+		}
+
+		if _, exist := concreteFuncs[imethod.Name()]; exist {
+			if !types.Identical(cmethod.Type(), imethod.Type()) {
+				return fmt.Errorf("method %s.%s already exists but has the wrong type: got %s, want %s",
+					conc.Name(), imethod.Name(), cmethod.Type(), imethod.Type())
+			}
+			continue
+		}
+
+		mf := missingFn{fn: imethod}
+		if isStruct && len(index) > 0 {
+			field := concreteStruct.Field(index[0])
+
+			fn := field.Name()
+			if _, ok := field.Type().(*types.Pointer); ok {
+				fn = "*" + fn
+			}
+
+			mf.needSubtle = fmt.Sprintf("// Subtle: this method shadows the method (%s).%s of %s.%s.\n", fn, imethod.Name(), si.Concrete.Obj().Name(), field.Name())
+		}
+
+		missing = append(missing, mf)
+	}
+	if len(missing) == 0 {
+		return fmt.Errorf("no missing methods found")
+	}
+
+	// Format interface name (used only in a comment).
+	iface := si.Interface.Name()
+	if ipkg := si.Interface.Pkg(); ipkg != nil && ipkg != conc.Pkg() {
+		iface = ipkg.Name() + "." + iface
+	}
+
+	// Pointer receiver?
+	var star string
+	if si.pointer {
+		star = "*"
+	}
+
+	// If there are any that have named receiver, choose the first one.
+	// Otherwise, use lowercase for the first letter of the object.
+	rn := strings.ToLower(si.Concrete.Obj().Name()[0:1])
+	if named, ok := types.Unalias(si.Concrete).(*types.Named); ok {
+		for i := 0; i < named.NumMethods(); i++ {
+			if recv := named.Method(i).Type().(*types.Signature).Recv(); recv.Name() != "" {
+				rn = recv.Name()
+				break
+			}
+		}
+	}
+
+	// Check for receiver name conflicts
+	checkRecvName := func(tuple *types.Tuple) bool {
+		for i := 0; i < tuple.Len(); i++ {
+			if rn == tuple.At(i).Name() {
+				return true
+			}
+		}
+		return false
+	}
+
+	for index := range missing {
+		mrn := rn + " "
+		sig := missing[index].fn.Signature()
+		if checkRecvName(sig.Params()) || checkRecvName(sig.Results()) {
+			mrn = ""
+		}
+
+		fmt.Fprintf(out, `// %s implements %s.
+%sfunc (%s%s%s%s) %s%s {
+	panic("unimplemented")
+}
+`,
+			missing[index].fn.Name(),
+			iface,
+			missing[index].needSubtle,
+			mrn,
+			star,
+			si.Concrete.Obj().Name(),
+			typesutil.FormatTypeParams(typesinternal.TypeParams(si.Concrete)),
+			missing[index].fn.Name(),
+			strings.TrimPrefix(types.TypeString(missing[index].fn.Type(), qual), "func"))
+	}
+	return nil
+}
+
 // fromCallExpr tries to find an *ast.CallExpr's function declaration and
 // analyzes a function call's signature against the passed in parameter to deduce
 // the concrete and interface types.
-func fromCallExpr(fset *token.FileSet, info *types.Info, pos token.Pos, call *ast.CallExpr) *StubInfo {
+func fromCallExpr(fset *token.FileSet, info *types.Info, pos token.Pos, call *ast.CallExpr) *IfaceStubInfo {
 	// Find argument containing pos.
 	argIdx := -1
 	var arg ast.Expr
@@ -118,10 +244,10 @@ func fromCallExpr(fset *token.FileSet, info *types.Info, pos token.Pos, call *as
 	if iface == nil {
 		return nil
 	}
-	return &StubInfo{
+	return &IfaceStubInfo{
 		Fset:      fset,
 		Concrete:  concType,
-		Pointer:   pointer,
+		pointer:   pointer,
 		Interface: iface,
 	}
 }
@@ -130,8 +256,8 @@ func fromCallExpr(fset *token.FileSet, info *types.Info, pos token.Pos, call *as
 // a concrete type that is trying to be returned as an interface type.
 //
 // For example, func() io.Writer { return myType{} }
-// would return StubInfo with the interface being io.Writer and the concrete type being myType{}.
-func fromReturnStmt(fset *token.FileSet, info *types.Info, pos token.Pos, path []ast.Node, ret *ast.ReturnStmt) (*StubInfo, error) {
+// would return StubIfaceInfo with the interface being io.Writer and the concrete type being myType{}.
+func fromReturnStmt(fset *token.FileSet, info *types.Info, pos token.Pos, path []ast.Node, ret *ast.ReturnStmt) (*IfaceStubInfo, error) {
 	// Find return operand containing pos.
 	returnIdx := -1
 	for i, r := range ret.Results {
@@ -148,6 +274,11 @@ func fromReturnStmt(fset *token.FileSet, info *types.Info, pos token.Pos, path [
 	if concType == nil || concType.Obj().Pkg() == nil {
 		return nil, nil
 	}
+	conc := concType.Obj()
+	if conc.Parent() != conc.Pkg().Scope() {
+		return nil, fmt.Errorf("local type %q cannot be stubbed", conc.Name())
+	}
+
 	funcType := enclosingFunction(path, info)
 	if funcType == nil {
 		return nil, fmt.Errorf("could not find the enclosing function of the return statement")
@@ -161,17 +292,17 @@ func fromReturnStmt(fset *token.FileSet, info *types.Info, pos token.Pos, path [
 	if iface == nil {
 		return nil, nil
 	}
-	return &StubInfo{
+	return &IfaceStubInfo{
 		Fset:      fset,
 		Concrete:  concType,
-		Pointer:   pointer,
+		pointer:   pointer,
 		Interface: iface,
 	}, nil
 }
 
-// fromValueSpec returns *StubInfo from a variable declaration such as
+// fromValueSpec returns *StubIfaceInfo from a variable declaration such as
 // var x io.Writer = &T{}
-func fromValueSpec(fset *token.FileSet, info *types.Info, spec *ast.ValueSpec, pos token.Pos) *StubInfo {
+func fromValueSpec(fset *token.FileSet, info *types.Info, spec *ast.ValueSpec, pos token.Pos) *IfaceStubInfo {
 	// Find RHS element containing pos.
 	var rhs ast.Expr
 	for _, r := range spec.Values {
@@ -195,22 +326,27 @@ func fromValueSpec(fset *token.FileSet, info *types.Info, spec *ast.ValueSpec, p
 	if concType == nil || concType.Obj().Pkg() == nil {
 		return nil
 	}
+	conc := concType.Obj()
+	if conc.Parent() != conc.Pkg().Scope() {
+		return nil
+	}
+
 	ifaceObj := ifaceType(ifaceNode, info)
 	if ifaceObj == nil {
 		return nil
 	}
-	return &StubInfo{
+	return &IfaceStubInfo{
 		Fset:      fset,
 		Concrete:  concType,
 		Interface: ifaceObj,
-		Pointer:   pointer,
+		pointer:   pointer,
 	}
 }
 
-// fromAssignStmt returns *StubInfo from a variable assignment such as
+// fromAssignStmt returns *StubIfaceInfo from a variable assignment such as
 // var x io.Writer
 // x = &T{}
-func fromAssignStmt(fset *token.FileSet, info *types.Info, assign *ast.AssignStmt, pos token.Pos) *StubInfo {
+func fromAssignStmt(fset *token.FileSet, info *types.Info, assign *ast.AssignStmt, pos token.Pos) *IfaceStubInfo {
 	// The interface conversion error in an assignment is against the RHS:
 	//
 	//      var x io.Writer
@@ -245,11 +381,15 @@ func fromAssignStmt(fset *token.FileSet, info *types.Info, assign *ast.AssignStm
 	if concType == nil || concType.Obj().Pkg() == nil {
 		return nil
 	}
-	return &StubInfo{
+	conc := concType.Obj()
+	if conc.Parent() != conc.Pkg().Scope() {
+		return nil
+	}
+	return &IfaceStubInfo{
 		Fset:      fset,
 		Concrete:  concType,
 		Interface: ifaceObj,
-		Pointer:   pointer,
+		pointer:   pointer,
 	}
 }
 
diff --git a/gopls/internal/golang/types_format.go b/gopls/internal/golang/types_format.go
index 41828244e11..55abb06a0ea 100644
--- a/gopls/internal/golang/types_format.go
+++ b/gopls/internal/golang/types_format.go
@@ -177,25 +177,6 @@ func formatFieldList(ctx context.Context, fset *token.FileSet, list *ast.FieldLi
 	return result, writeResultParens
 }
 
-// FormatTypeParams turns TypeParamList into its Go representation, such as:
-// [T, Y]. Note that it does not print constraints as this is mainly used for
-// formatting type params in method receivers.
-func FormatTypeParams(tparams *types.TypeParamList) string {
-	if tparams == nil || tparams.Len() == 0 {
-		return ""
-	}
-	var buf bytes.Buffer
-	buf.WriteByte('[')
-	for i := 0; i < tparams.Len(); i++ {
-		if i > 0 {
-			buf.WriteString(", ")
-		}
-		buf.WriteString(tparams.At(i).Obj().Name())
-	}
-	buf.WriteByte(']')
-	return buf.String()
-}
-
 // NewSignature returns formatted signature for a types.Signature struct.
 func NewSignature(ctx context.Context, s *cache.Snapshot, pkg *cache.Package, sig *types.Signature, comment *ast.CommentGroup, qf types.Qualifier, mq MetadataQualifier) (*signature, error) {
 	var tparams []string
diff --git a/gopls/internal/test/marker/testdata/stubmethods/fromcall_basic.txt b/gopls/internal/test/marker/testdata/stubmethods/fromcall_basic.txt
new file mode 100644
index 00000000000..3c6169c34b4
--- /dev/null
+++ b/gopls/internal/test/marker/testdata/stubmethods/fromcall_basic.txt
@@ -0,0 +1,54 @@
+This test checks the basic of 'Declare missing method T.f' quick fix.
+
+-- basic_stub.go --
+package fromcallbasic
+
+type Basic struct{}
+
+func basic() {
+	i := 1
+	b := Basic{}
+	f(b.basic(i)) //@suggestedfix("basic", re"has no field or method", basic)
+}
+
+func f(i int) string { return "s" }
+-- @basic/basic_stub.go --
+@@ -5 +5,4 @@
++func (b Basic) basic(i int) int {
++	panic("unimplemented")
++}
++
+-- pointer.go --
+package fromcallbasic
+
+type P struct{}
+
+func recv_param_pointer() {
+	p := &P{}
+	i := 42
+	p.pointer(&i) //@suggestedfix("pointer", re"has no field or method", pointer)
+}
+-- @pointer/pointer.go --
+@@ -5 +5,4 @@
++func (p *P) pointer(i *int) {
++	panic("unimplemented")
++}
++
+-- other.go --
+package fromcallbasic
+
+type TypeDeclInOtherFile struct{}
+
+-- this.go --
+package fromcallbasic
+
+func fun() {
+	i := 1
+	t := TypeDeclInOtherFile{}
+	t.other(i) //@suggestedfix("other", re"has no field or method", del_other)
+}
+-- @del_other/other.go --
+@@ -5 +5,3 @@
++func (t TypeDeclInOtherFile) other(i int) {
++	panic("unimplemented")
++}
diff --git a/gopls/internal/test/marker/testdata/stubmethods/fromcall_params.txt b/gopls/internal/test/marker/testdata/stubmethods/fromcall_params.txt
new file mode 100644
index 00000000000..caa263afdbb
--- /dev/null
+++ b/gopls/internal/test/marker/testdata/stubmethods/fromcall_params.txt
@@ -0,0 +1,84 @@
+This test checks the param name and type of the generated missing method based on CallExpr.
+
+-- basic_stub.go --
+package fromcallparams
+
+type A struct{}
+
+func untypedParams() {
+	a := A{}
+	a.untyped("s", 42, 4.12, make(map[string]int), []int{1}, [1]int{1}, make(chan string)) //@suggestedfix("untyped", re"has no field or method", basic)
+}
+-- @basic/basic_stub.go --
+@@ -5 +5,4 @@
++func (a A) untyped(s string, i int, f float64, m map[string]int, param5 []int, param6 [1]int, ch chan string) {
++	panic("unimplemented")
++}
++
+-- nonexistent_type.go --
+package fromcallparams
+
+type B struct{}
+
+func invalidBasicKindParam() {
+	b := B{}
+	b.basicKind(NonExistentType{}) //@suggestedfix("basicKind", re"has no field or method", nonexistent),diag(re"NonExistentType",re"undefined: NonExistentType")
+}
+-- @nonexistent/nonexistent_type.go --
+@@ -5 +5,4 @@
++func (b B) basicKind(param any) {
++	panic("unimplemented")
++}
++
+-- pass_param_by_ident.go --
+package fromcallparams
+
+type C struct{}
+
+func passParamByIdent() {
+	c := C{}
+	stringVar := "some string"
+	intVar := 1
+	sliceVar := []int{1}
+	c.ident(stringVar, intVar, sliceVar) //@suggestedfix("ident", re"has no field or method", ident)
+}
+-- @ident/pass_param_by_ident.go --
+@@ -5 +5,4 @@
++func (c C) ident(stringVar string, intVar int, sliceVar []int) {
++	panic("unimplemented")
++}
++
+-- tail_param_name.go --
+package fromcallparams
+
+type Tail struct{}
+
+type TypeWithLongName struct{}
+
+func TailParamName() {
+	t := Tail{}
+	t.longName(TypeWithLongName{}) //@suggestedfix("longName", re"has no field or method", trail)
+}
+-- @trail/tail_param_name.go --
+@@ -5 +5,4 @@
++func (t Tail) longName(name TypeWithLongName) {
++	panic("unimplemented")
++}
++
+-- selector_param_name.go --
+package fromcallparams
+
+import "net/http"
+
+type Select struct{}
+
+func selectExpr() {
+	s := Select{}
+	s.sel(http.ErrNotMultipart) //@suggestedfix("sel", re"has no field or method", select)
+}
+-- @select/selector_param_name.go --
+@@ -7 +7,4 @@
++func (s Select) sel(multipart *http.ProtocolError) {
++	panic("unimplemented")
++}
++
diff --git a/gopls/internal/test/marker/testdata/stubmethods/fromcall_returns.txt b/gopls/internal/test/marker/testdata/stubmethods/fromcall_returns.txt
new file mode 100644
index 00000000000..f7fb144a144
--- /dev/null
+++ b/gopls/internal/test/marker/testdata/stubmethods/fromcall_returns.txt
@@ -0,0 +1,109 @@
+This test checks the return type of the generated missing method based on CallExpr.
+
+-- basic_stub.go --
+package fromcallreturns
+
+-- param.go --
+package fromcallreturns
+
+type A struct{}
+
+func inferFromParam() {
+	a := A{}
+	f(a.as_param()) //@suggestedfix("as_param", re"has no field or method", infer_param)
+}
+
+func f(i int) {}
+-- @infer_param/param.go --
+@@ -5 +5,4 @@
++func (a A) as_param() int {
++	panic("unimplemented")
++}
++
+-- assign.go --
+package fromcallreturns
+
+type Assign struct{}
+
+func inferReturnfromAssign() {
+	var assign int //@diag("assign",re"not used")
+	a := Assign{}
+	assign = a.as_assign() //@suggestedfix("as_assign", re"has no field or method", infer_assign)
+}
+-- @infer_assign/assign.go --
+@@ -5 +5,4 @@
++func (a Assign) as_assign() int {
++	panic("unimplemented")
++}
++
+-- multiple_assign.go --
+package fromcallreturns
+
+type MultiAssign struct{}
+
+func inferReturnfromMultipleAssign() {
+	var assign1 int //@diag("assign1",re"not used")
+	var assign2 int //@diag("assign2",re"not used")
+	m := MultiAssign{}
+	assign1, assign2 = m.multi_assign() //@suggestedfix("multi_assign", re"has no field or method", infer_multiple_assign)
+}
+-- @infer_multiple_assign/multiple_assign.go --
+@@ -5 +5,4 @@
++func (m MultiAssign) multi_assign() (int, int) {
++	panic("unimplemented")
++}
++
+-- multiple_return_in_param.go --
+package fromcallreturns
+
+type MultiReturn struct{}
+
+func inferMultipleReturnInParam() {
+	m := MultiReturn{}
+	m.param_has_multi_return(multiReturn()) //@suggestedfix("param_has_multi_return", re"has no field or method", multiple_return)
+}
+
+func multiReturn() (int, int) {
+	return 1, 1
+}
+-- @multiple_return/multiple_return_in_param.go --
+@@ -5 +5,4 @@
++func (m MultiReturn) param_has_multi_return(i int, param2 int) {
++	panic("unimplemented")
++}
++
+-- error_nodes.go --
+package fromcallreturns
+
+type E struct{}
+
+func all_error() {
+	e := E{}
+	errorFunc(e.errors(undefined1(), undefined2(), undefined3{})) //@suggestedfix("errors", re"has no field or method", all_error),diag("undefined1",re"undefined"),diag("undefined2",re"undefined"),diag("undefined3",re"undefined")
+}
+func errorFunc(u undefined4) {} //@diag("undefined4",re"undefined")
+-- @all_error/error_nodes.go --
+@@ -5 +5,4 @@
++func (e E) errors(param any, param2 any, param3 any) any {
++	panic("unimplemented")
++}
++
+-- paren.go --
+package fromcallreturns
+
+type Paren struct{}
+
+func paren() {
+	p := Paren{}
+	fn()((p.surroundingParen())) //@suggestedfix("surroundingParen", re"has no field or method", surrounding_paren)
+}
+
+func fn() func(i int) {
+	return func(i int) {}
+}
+-- @surrounding_paren/paren.go --
+@@ -5 +5,4 @@
++func (p Paren) surroundingParen() int {
++	panic("unimplemented")
++}
++
diff --git a/gopls/internal/test/marker/testdata/suggestedfix/stub.txt b/gopls/internal/test/marker/testdata/suggestedfix/stub.txt
index fc10d8e58ad..0d325b700cf 100644
--- a/gopls/internal/test/marker/testdata/suggestedfix/stub.txt
+++ b/gopls/internal/test/marker/testdata/suggestedfix/stub.txt
@@ -327,40 +327,3 @@ type writer struct{}
 +func (w writer) Write(p []byte) (n int, err error) {
 +	panic("unimplemented")
 +}
--- typedecl_group.go --
-package stub
-
-// Regression test for Issue #56825: file corrupted by insertion of
-// methods after TypeSpec in a parenthesized TypeDecl.
-
-import "io"
-
-func newReadCloser() io.ReadCloser {
-	return rdcloser{} //@suggestedfix("rd", re"does not implement", typedecl_group)
-}
-
-type (
-	A        int
-	rdcloser struct{}
-	B        int
-)
-
-func _() {
-	// Local types can't be stubbed as there's nowhere to put the methods.
-	// Check that executing the code action causes an error, not file corruption.
-	// TODO(adonovan): it would be better not to offer the quick fix in this case.
-	type local struct{}
-	var _ io.ReadCloser = local{} //@suggestedfixerr("local", re"does not implement", "local type \"local\" cannot be stubbed")
-}
--- @typedecl_group/typedecl_group.go --
-@@ -18 +18,10 @@
-+// Close implements io.ReadCloser.
-+func (r rdcloser) Close() error {
-+	panic("unimplemented")
-+}
-+
-+// Read implements io.ReadCloser.
-+func (r rdcloser) Read(p []byte) (n int, err error) {
-+	panic("unimplemented")
-+}
-+
diff --git a/gopls/internal/util/typesutil/typesutil.go b/gopls/internal/util/typesutil/typesutil.go
index 6e61c7ed874..11233e80bd2 100644
--- a/gopls/internal/util/typesutil/typesutil.go
+++ b/gopls/internal/util/typesutil/typesutil.go
@@ -5,6 +5,7 @@
 package typesutil
 
 import (
+	"bytes"
 	"go/ast"
 	"go/types"
 )
@@ -34,3 +35,22 @@ func FileQualifier(f *ast.File, pkg *types.Package, info *types.Info) types.Qual
 		return p.Name()
 	}
 }
+
+// FormatTypeParams turns TypeParamList into its Go representation, such as:
+// [T, Y]. Note that it does not print constraints as this is mainly used for
+// formatting type params in method receivers.
+func FormatTypeParams(tparams *types.TypeParamList) string {
+	if tparams == nil || tparams.Len() == 0 {
+		return ""
+	}
+	var buf bytes.Buffer
+	buf.WriteByte('[')
+	for i := 0; i < tparams.Len(); i++ {
+		if i > 0 {
+			buf.WriteString(", ")
+		}
+		buf.WriteString(tparams.At(i).Obj().Name())
+	}
+	buf.WriteByte(']')
+	return buf.String()
+}