diff --git a/gopls/doc/analyzers.md b/gopls/doc/analyzers.md
index 80ee65d..c3e19ac 100644
--- a/gopls/doc/analyzers.md
+++ b/gopls/doc/analyzers.md
@@ -573,6 +573,25 @@
 
 **Enabled by default.**
 
+## **implementmissing**
+
+suggested fixes for "undeclared name: %s" on a function call
+
+This checker provides suggested fixes for type errors of the
+type "undeclared name: %s" that happen for a function call. For example:
+	func m() {
+	  a(1)
+	}
+will turn into
+	func m() {
+	  a(1)
+	}
+
+	func a(i int) {}
+
+
+**Disabled by default. Enable it by setting `"analyses": {"implementmissing": true}`.**
+
 ## **nonewvars**
 
 suggested fixes for "no new vars on left side of :="
diff --git a/internal/lsp/analysis/implementmissing/missingfunc.go b/internal/lsp/analysis/implementmissing/missingfunc.go
new file mode 100644
index 0000000..2e4bc3c
--- /dev/null
+++ b/internal/lsp/analysis/implementmissing/missingfunc.go
@@ -0,0 +1,274 @@
+// Copyright 2021 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 implementmissing defines an Analyzer that will attempt to
+// automatically implement a function that is currently undeclared.
+package implementmissing
+
+import (
+	"bytes"
+	"fmt"
+	"go/ast"
+	"go/format"
+	"go/types"
+	"strings"
+	"unicode"
+
+	"golang.org/x/tools/go/analysis"
+	"golang.org/x/tools/go/ast/astutil"
+	"golang.org/x/tools/internal/analysisinternal"
+)
+
+const Doc = `suggested fixes for "undeclared name: %s" on a function call
+
+This checker provides suggested fixes for type errors of the
+type "undeclared name: %s" that happen for a function call. For example:
+	func m() {
+	  a(1)
+	}
+will turn into
+	func m() {
+	  a(1)
+	}
+
+	func a(i int) {}
+`
+
+var Analyzer = &analysis.Analyzer{
+	Name:             "implementmissing",
+	Doc:              Doc,
+	Requires:         []*analysis.Analyzer{},
+	Run:              run,
+	RunDespiteErrors: true,
+}
+
+const undeclaredNamePrefix = "undeclared name: "
+
+func run(pass *analysis.Pass) (interface{}, error) {
+	info := pass.TypesInfo
+	if info == nil {
+		return nil, fmt.Errorf("nil TypeInfo")
+	}
+
+	errors := analysisinternal.GetTypeErrors(pass)
+	for _, typeErr := range errors {
+		// Filter out the errors that are not relevant to this analyzer.
+		if !FixesError(typeErr.Msg) {
+			continue
+		}
+
+		var file *ast.File
+		for _, f := range pass.Files {
+			if f.Pos() <= typeErr.Pos && typeErr.Pos <= f.End() {
+				file = f
+				break
+			}
+		}
+		if file == nil {
+			continue
+		}
+
+		var buf bytes.Buffer
+		if err := format.Node(&buf, pass.Fset, file); err != nil {
+			continue
+		}
+		typeErrEndPos := analysisinternal.TypeErrorEndPos(pass.Fset, buf.Bytes(), typeErr.Pos)
+
+		// Get the path for the relevant range.
+		path, _ := astutil.PathEnclosingInterval(file, typeErr.Pos, typeErrEndPos)
+		if len(path) < 2 {
+			return nil, nil
+		}
+
+		// Check to make sure we're dealing with a function call, we don't want to
+		// deal with undeclared variables here.
+		call, ok := path[1].(*ast.CallExpr)
+		if !ok {
+			return nil, nil
+		}
+
+		ident, ok := path[0].(*ast.Ident)
+		if !ok {
+			return nil, nil
+		}
+
+		var paramNames []string
+		var paramTypes []types.Type
+
+		// keep track of all param names to later ensure uniqueness
+		namesCount := map[string]int{}
+
+		for _, arg := range call.Args {
+			ty := pass.TypesInfo.TypeOf(arg)
+			if ty == nil {
+				return nil, nil
+			}
+
+			switch t := ty.(type) {
+			// this is the case where another function call returning multiple
+			// results is used as an argument
+			case *types.Tuple:
+				n := t.Len()
+				for i := 0; i < n; i++ {
+					name := typeToArgName(t.At(i).Type())
+					namesCount[name]++
+
+					paramNames = append(paramNames, name)
+					paramTypes = append(paramTypes, types.Default(t.At(i).Type()))
+				}
+
+			default:
+				// does the argument have a name we can reuse?
+				// only happens in case of a *ast.Ident
+				var name string
+				if ident, ok := arg.(*ast.Ident); ok {
+					name = ident.Name
+				}
+
+				if name == "" {
+					name = typeToArgName(ty)
+				}
+
+				namesCount[name]++
+
+				paramNames = append(paramNames, name)
+				paramTypes = append(paramTypes, types.Default(ty))
+			}
+		}
+
+		for n, c := range namesCount {
+			// Any names we saw more than once will need a unique suffix added
+			// on. Reset the count to 1 to act as the suffix for the first
+			// occurrence of that name.
+			if c >= 2 {
+				namesCount[n] = 1
+			} else {
+				delete(namesCount, n)
+			}
+		}
+
+		params := &ast.FieldList{
+			List: []*ast.Field{},
+		}
+
+		for i, name := range paramNames {
+			if suffix, repeats := namesCount[name]; repeats {
+				namesCount[name]++
+				name = fmt.Sprintf("%s%d", name, suffix)
+			}
+
+			// only worth checking after previous param in the list
+			if i > 0 {
+				// if type of parameter at hand is the same as the previous one,
+				// add it to the previous param list of identifiers so to have:
+				//  (s1, s2 string)
+				// and not
+				//  (s1 string, s2 string)
+				if paramTypes[i] == paramTypes[i-1] {
+					params.List[len(params.List)-1].Names = append(params.List[len(params.List)-1].Names, ast.NewIdent(name))
+					continue
+				}
+			}
+
+			params.List = append(params.List, &ast.Field{
+				Names: []*ast.Ident{
+					ast.NewIdent(name),
+				},
+				Type: analysisinternal.TypeExpr(pass.Fset, file, pass.Pkg, paramTypes[i]),
+			})
+		}
+
+		eof := file.End()
+
+		decl := &ast.FuncDecl{
+			Name: &ast.Ident{
+				Name: ident.Name,
+			},
+			Type: &ast.FuncType{
+				Func:    file.End(),
+				Params:  params,
+				Results: &ast.FieldList{},
+			},
+			Body: &ast.BlockStmt{
+				List: []ast.Stmt{
+					&ast.ExprStmt{
+						X: &ast.CallExpr{
+							Fun: &ast.Ident{
+								Name: "panic",
+							},
+							Args: []ast.Expr{
+								&ast.BasicLit{
+									Value: `"not implemented"`,
+								},
+							},
+						},
+					},
+				},
+			},
+		}
+
+		var declBuf bytes.Buffer
+		if err := format.Node(&declBuf, pass.Fset, decl); err != nil {
+			return nil, err
+		}
+
+		text := append([]byte("\n\n"), declBuf.Bytes()...)
+		text = append(text, []byte("\n")...)
+
+		pass.Report(analysis.Diagnostic{
+			Pos:     typeErr.Pos,
+			End:     typeErr.Pos,
+			Message: typeErr.Msg,
+			SuggestedFixes: []analysis.SuggestedFix{
+				{
+					Message: "Implement function " + ident.Name,
+					TextEdits: []analysis.TextEdit{{
+						Pos:     eof,
+						End:     eof,
+						NewText: text,
+					}},
+				},
+			},
+			Related: []analysis.RelatedInformation{},
+		})
+	}
+	return nil, nil
+}
+
+func FixesError(msg string) bool {
+	return strings.HasPrefix(msg, undeclaredNamePrefix)
+}
+
+func typeToArgName(ty types.Type) string {
+	s := types.Default(ty).String()
+
+	switch t := ty.(type) {
+	case *types.Basic:
+		// use first letter in type name for basic types
+		return s[0:1]
+	case *types.Slice:
+		// use element type to decide var name for slices
+		return typeToArgName(t.Elem())
+	case *types.Array:
+		// use element type to decide var name for arrays
+		return typeToArgName(t.Elem())
+	case *types.Chan:
+		return "ch"
+	}
+
+	s = strings.TrimFunc(s, func(r rune) bool {
+		return !unicode.IsLetter(r)
+	})
+
+	if s == "error" {
+		return "err"
+	}
+
+	// remove package (if present)
+	// and make first letter lowercase
+	parts := strings.Split(s, ".")
+	a := []rune(parts[len(parts)-1])
+	a[0] = unicode.ToLower(a[0])
+	return string(a)
+}
diff --git a/internal/lsp/analysis/implementmissing/missingfunc_test.go b/internal/lsp/analysis/implementmissing/missingfunc_test.go
new file mode 100644
index 0000000..7c9b573
--- /dev/null
+++ b/internal/lsp/analysis/implementmissing/missingfunc_test.go
@@ -0,0 +1,17 @@
+// Copyright 2021 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 implementmissing_test
+
+import (
+	"testing"
+
+	"golang.org/x/tools/go/analysis/analysistest"
+	"golang.org/x/tools/internal/lsp/analysis/implementmissing"
+)
+
+func Test(t *testing.T) {
+	testdata := analysistest.TestData()
+	analysistest.RunWithSuggestedFixes(t, testdata, implementmissing.Analyzer, "missingfunction")
+}
diff --git a/internal/lsp/analysis/implementmissing/testdata/src/missingfunction/channels.go b/internal/lsp/analysis/implementmissing/testdata/src/missingfunction/channels.go
new file mode 100644
index 0000000..fa91518
--- /dev/null
+++ b/internal/lsp/analysis/implementmissing/testdata/src/missingfunction/channels.go
@@ -0,0 +1,13 @@
+// Copyright 2021 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 missingfunction
+
+func channels(s string) {
+	undefinedChannels(c()) // want "undeclared name: undefinedChannels"
+}
+
+func c() (<-chan string, chan string) {
+	return make(<-chan string), make(chan string)
+}
diff --git a/internal/lsp/analysis/implementmissing/testdata/src/missingfunction/channels.go.golden b/internal/lsp/analysis/implementmissing/testdata/src/missingfunction/channels.go.golden
new file mode 100644
index 0000000..c8578e6
--- /dev/null
+++ b/internal/lsp/analysis/implementmissing/testdata/src/missingfunction/channels.go.golden
@@ -0,0 +1,15 @@
+// Copyright 2021 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 missingfunction
+
+func channels(s string) {
+	undefinedChannels(c()) // want "undeclared name: undefinedChannels"
+}
+
+func c() (<-chan string, chan string) {
+	return make(<-chan string), make(chan string)
+}
+
+func undefinedChannels(ch1 <-chan string, ch2 chan string) { panic("not implemented") }
diff --git a/internal/lsp/analysis/implementmissing/testdata/src/missingfunction/consecutive_params.go b/internal/lsp/analysis/implementmissing/testdata/src/missingfunction/consecutive_params.go
new file mode 100644
index 0000000..4a6ec62
--- /dev/null
+++ b/internal/lsp/analysis/implementmissing/testdata/src/missingfunction/consecutive_params.go
@@ -0,0 +1,10 @@
+// Copyright 2021 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 missingfunction
+
+func consecutiveParams() {
+	var s string
+	undefinedConsecutiveParams(s, s) // want "undeclared name: undefinedConsecutiveParams"
+}
diff --git a/internal/lsp/analysis/implementmissing/testdata/src/missingfunction/consecutive_params.go.golden b/internal/lsp/analysis/implementmissing/testdata/src/missingfunction/consecutive_params.go.golden
new file mode 100644
index 0000000..050b0fc
--- /dev/null
+++ b/internal/lsp/analysis/implementmissing/testdata/src/missingfunction/consecutive_params.go.golden
@@ -0,0 +1,12 @@
+// Copyright 2021 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 missingfunction
+
+func consecutiveParams() {
+	var s string
+	undefinedConsecutiveParams(s, s) // want "undeclared name: undefinedConsecutiveParams"
+}
+
+func undefinedConsecutiveParams(s1, s2 string) { panic("not implemented") }
diff --git a/internal/lsp/analysis/implementmissing/testdata/src/missingfunction/error_param.go b/internal/lsp/analysis/implementmissing/testdata/src/missingfunction/error_param.go
new file mode 100644
index 0000000..49c5258
--- /dev/null
+++ b/internal/lsp/analysis/implementmissing/testdata/src/missingfunction/error_param.go
@@ -0,0 +1,10 @@
+// Copyright 2021 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 missingfunction
+
+func errorParam() {
+	var err error
+	undefinedErrorParam(err) // want "undeclared name: undefinedErrorParam"
+}
diff --git a/internal/lsp/analysis/implementmissing/testdata/src/missingfunction/error_param.go.golden b/internal/lsp/analysis/implementmissing/testdata/src/missingfunction/error_param.go.golden
new file mode 100644
index 0000000..1661fc4
--- /dev/null
+++ b/internal/lsp/analysis/implementmissing/testdata/src/missingfunction/error_param.go.golden
@@ -0,0 +1,12 @@
+// Copyright 2021 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 missingfunction
+
+func errorParam() {
+	var err error
+	undefinedErrorParam(err) // want "undeclared name: undefinedErrorParam"
+}
+
+func undefinedErrorParam(err error) { panic("not implemented") }
diff --git a/internal/lsp/analysis/implementmissing/testdata/src/missingfunction/literals.go b/internal/lsp/analysis/implementmissing/testdata/src/missingfunction/literals.go
new file mode 100644
index 0000000..46c045c
--- /dev/null
+++ b/internal/lsp/analysis/implementmissing/testdata/src/missingfunction/literals.go
@@ -0,0 +1,11 @@
+// Copyright 2021 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 missingfunction
+
+type T struct{}
+
+func literals() {
+	undefinedLiterals("hey compiler", T{}, &T{}) // want "undeclared name: undefinedLiterals"
+}
diff --git a/internal/lsp/analysis/implementmissing/testdata/src/missingfunction/literals.go.golden b/internal/lsp/analysis/implementmissing/testdata/src/missingfunction/literals.go.golden
new file mode 100644
index 0000000..ee32b71
--- /dev/null
+++ b/internal/lsp/analysis/implementmissing/testdata/src/missingfunction/literals.go.golden
@@ -0,0 +1,13 @@
+// Copyright 2021 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 missingfunction
+
+type T struct{}
+
+func literals() {
+	undefinedLiterals("hey compiler", T{}, &T{}) // want "undeclared name: undefinedLiterals"
+}
+
+func undefinedLiterals(s string, t1 T, t2 *T) { panic("not implemented") }
diff --git a/internal/lsp/analysis/implementmissing/testdata/src/missingfunction/operation.go b/internal/lsp/analysis/implementmissing/testdata/src/missingfunction/operation.go
new file mode 100644
index 0000000..b8330ec
--- /dev/null
+++ b/internal/lsp/analysis/implementmissing/testdata/src/missingfunction/operation.go
@@ -0,0 +1,11 @@
+// Copyright 2021 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 missingfunction
+
+import "time"
+
+func operation() {
+	undefinedOperation(10 * time.Second) // want "undeclared name: undefinedOperation"
+}
diff --git a/internal/lsp/analysis/implementmissing/testdata/src/missingfunction/operation.go.golden b/internal/lsp/analysis/implementmissing/testdata/src/missingfunction/operation.go.golden
new file mode 100644
index 0000000..1bf35cf
--- /dev/null
+++ b/internal/lsp/analysis/implementmissing/testdata/src/missingfunction/operation.go.golden
@@ -0,0 +1,13 @@
+// Copyright 2021 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 missingfunction
+
+import "time"
+
+func operation() {
+	undefinedOperation(10 * time.Second) // want "undeclared name: undefinedOperation"
+}
+
+func undefinedOperation(duration time.Duration) { panic("not implemented") }
diff --git a/internal/lsp/analysis/implementmissing/testdata/src/missingfunction/selector.go b/internal/lsp/analysis/implementmissing/testdata/src/missingfunction/selector.go
new file mode 100644
index 0000000..5db716f
--- /dev/null
+++ b/internal/lsp/analysis/implementmissing/testdata/src/missingfunction/selector.go
@@ -0,0 +1,10 @@
+// Copyright 2021 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 missingfunction
+
+func selector() {
+	m := map[int]bool{}
+	undefinedSelector(m[1]) // want "undeclared name: undefinedSelector"
+}
diff --git a/internal/lsp/analysis/implementmissing/testdata/src/missingfunction/selector.go.golden b/internal/lsp/analysis/implementmissing/testdata/src/missingfunction/selector.go.golden
new file mode 100644
index 0000000..9d66f6a
--- /dev/null
+++ b/internal/lsp/analysis/implementmissing/testdata/src/missingfunction/selector.go.golden
@@ -0,0 +1,12 @@
+// Copyright 2021 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 missingfunction
+
+func selector() {
+	m := map[int]bool{}
+	undefinedSelector(m[1]) // want "undeclared name: undefinedSelector"
+}
+
+func undefinedSelector(b bool) { panic("not implemented") }
diff --git a/internal/lsp/analysis/implementmissing/testdata/src/missingfunction/slice.go b/internal/lsp/analysis/implementmissing/testdata/src/missingfunction/slice.go
new file mode 100644
index 0000000..179954c
--- /dev/null
+++ b/internal/lsp/analysis/implementmissing/testdata/src/missingfunction/slice.go
@@ -0,0 +1,9 @@
+// Copyright 2021 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 missingfunction
+
+func slice() {
+	undefinedSlice([]int{1, 2}) // want "undeclared name: undefinedSlice"
+}
diff --git a/internal/lsp/analysis/implementmissing/testdata/src/missingfunction/slice.go.golden b/internal/lsp/analysis/implementmissing/testdata/src/missingfunction/slice.go.golden
new file mode 100644
index 0000000..75f4578
--- /dev/null
+++ b/internal/lsp/analysis/implementmissing/testdata/src/missingfunction/slice.go.golden
@@ -0,0 +1,11 @@
+// Copyright 2021 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 missingfunction
+
+func slice() {
+	undefinedSlice([]int{1, 2}) // want "undeclared name: undefinedSlice"
+}
+
+func undefinedSlice(i []int) { panic("not implemented") }
diff --git a/internal/lsp/analysis/implementmissing/testdata/src/missingfunction/tuple.go b/internal/lsp/analysis/implementmissing/testdata/src/missingfunction/tuple.go
new file mode 100644
index 0000000..673f607
--- /dev/null
+++ b/internal/lsp/analysis/implementmissing/testdata/src/missingfunction/tuple.go
@@ -0,0 +1,13 @@
+// Copyright 2021 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 missingfunction
+
+func tuple() {
+	undefinedTuple(b()) // want "undeclared name: undefinedTuple"
+}
+
+func b() (string, error) {
+	return "", nil
+}
diff --git a/internal/lsp/analysis/implementmissing/testdata/src/missingfunction/tuple.go.golden b/internal/lsp/analysis/implementmissing/testdata/src/missingfunction/tuple.go.golden
new file mode 100644
index 0000000..ac33ed0
--- /dev/null
+++ b/internal/lsp/analysis/implementmissing/testdata/src/missingfunction/tuple.go.golden
@@ -0,0 +1,15 @@
+// Copyright 2021 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 missingfunction
+
+func tuple() {
+	undefinedTuple(b()) // want "undeclared name: undefinedTuple"
+}
+
+func b() (string, error) {
+	return "", nil
+}
+
+func undefinedTuple(s string, err error) { panic("not implemented") }
diff --git a/internal/lsp/analysis/implementmissing/testdata/src/missingfunction/unique_params.go b/internal/lsp/analysis/implementmissing/testdata/src/missingfunction/unique_params.go
new file mode 100644
index 0000000..2f18498
--- /dev/null
+++ b/internal/lsp/analysis/implementmissing/testdata/src/missingfunction/unique_params.go
@@ -0,0 +1,11 @@
+// Copyright 2021 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 missingfunction
+
+func uniqueArguments() {
+	var s string
+	var i int
+	undefinedUniqueArguments(s, i, s) // want "undeclared name: undefinedUniqueArguments"
+}
diff --git a/internal/lsp/analysis/implementmissing/testdata/src/missingfunction/unique_params.go.golden b/internal/lsp/analysis/implementmissing/testdata/src/missingfunction/unique_params.go.golden
new file mode 100644
index 0000000..28c27d8
--- /dev/null
+++ b/internal/lsp/analysis/implementmissing/testdata/src/missingfunction/unique_params.go.golden
@@ -0,0 +1,13 @@
+// Copyright 2021 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 missingfunction
+
+func uniqueArguments() {
+	var s string
+	var i int
+	undefinedUniqueArguments(s, i, s) // want "undeclared name: undefinedUniqueArguments"
+}
+
+func undefinedUniqueArguments(s1 string, i int, s2 string) { panic("not implemented") }
diff --git a/internal/lsp/source/api_json.go b/internal/lsp/source/api_json.go
index 9b5734f..4b67341 100755
--- a/internal/lsp/source/api_json.go
+++ b/internal/lsp/source/api_json.go
@@ -557,6 +557,11 @@
 							Default: "true",
 						},
 						{
+							Name:    "\"implementmissing\"",
+							Doc:     "suggested fixes for \"undeclared name: %s\" on a function call\n\nThis checker provides suggested fixes for type errors of the\ntype \"undeclared name: %s\" that happen for a function call. For example:\n\tfunc m() {\n\t  a(1)\n\t}\nwill turn into\n\tfunc m() {\n\t  a(1)\n\t}\n\n\tfunc a(i int) {}\n",
+							Default: "false",
+						},
+						{
 							Name:    "\"nonewvars\"",
 							Doc:     "suggested fixes for \"no new vars on left side of :=\"\n\nThis checker provides suggested fixes for type errors of the\ntype \"no new vars on left side of :=\". For example:\n\tz := 1\n\tz := 2\nwill turn into\n\tz := 1\n\tz = 2\n",
 							Default: "true",
@@ -1125,6 +1130,11 @@
 			Default: true,
 		},
 		{
+			Name:    "implementmissing",
+			Doc:     "suggested fixes for \"undeclared name: %s\" on a function call\n\nThis checker provides suggested fixes for type errors of the\ntype \"undeclared name: %s\" that happen for a function call. For example:\n\tfunc m() {\n\t  a(1)\n\t}\nwill turn into\n\tfunc m() {\n\t  a(1)\n\t}\n\n\tfunc a(i int) {}\n",
+			Default: false,
+		},
+		{
 			Name:    "nonewvars",
 			Doc:     "suggested fixes for \"no new vars on left side of :=\"\n\nThis checker provides suggested fixes for type errors of the\ntype \"no new vars on left side of :=\". For example:\n\tz := 1\n\tz := 2\nwill turn into\n\tz := 1\n\tz = 2\n",
 			Default: true,
diff --git a/internal/lsp/source/options.go b/internal/lsp/source/options.go
index 9bc73a9..19c9911 100644
--- a/internal/lsp/source/options.go
+++ b/internal/lsp/source/options.go
@@ -49,6 +49,7 @@
 	"golang.org/x/tools/go/analysis/passes/unusedwrite"
 	"golang.org/x/tools/internal/lsp/analysis/fillreturns"
 	"golang.org/x/tools/internal/lsp/analysis/fillstruct"
+	"golang.org/x/tools/internal/lsp/analysis/implementmissing"
 	"golang.org/x/tools/internal/lsp/analysis/nonewvars"
 	"golang.org/x/tools/internal/lsp/analysis/noresultvalues"
 	"golang.org/x/tools/internal/lsp/analysis/simplifycompositelit"
@@ -754,6 +755,9 @@
 	if _, ok := o.Analyses[unusedparams.Analyzer.Name]; !ok {
 		o.Analyses[unusedparams.Analyzer.Name] = true
 	}
+	if _, ok := o.Analyses[implementmissing.Analyzer.Name]; !ok {
+		o.Analyses[implementmissing.Analyzer.Name] = true
+	}
 }
 
 func (o *Options) set(name string, value interface{}, seen map[string]struct{}) OptionResult {
@@ -1171,6 +1175,11 @@
 			ActionKind: []protocol.CodeActionKind{protocol.SourceFixAll, protocol.QuickFix},
 			Enabled:    true,
 		},
+		implementmissing.Analyzer.Name: {
+			Analyzer:   implementmissing.Analyzer,
+			ActionKind: []protocol.CodeActionKind{protocol.SourceFixAll, protocol.QuickFix},
+			Enabled:    false,
+		},
 		nonewvars.Analyzer.Name: {
 			Analyzer: nonewvars.Analyzer,
 			Enabled:  true,