--- /dev/null
+// Copyright 2020 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 fillreturns defines an Analyzer that will attempt to
+// automatically fill in a return statement that has missing
+// values with zero value elements.
+package fillreturns
+
+import (
+ "bytes"
+ "fmt"
+ "go/ast"
+ "go/format"
+ "go/types"
+ "regexp"
+ "strconv"
+ "strings"
+
+ "golang.org/x/tools/go/analysis"
+ "golang.org/x/tools/go/ast/astutil"
+ "golang.org/x/tools/internal/analysisinternal"
+)
+
+const Doc = `suggested fixes for "wrong number of return values (want %d, got %d)"
+
+This checker provides suggested fixes for type errors of the
+type "wrong number of return values (want %d, got %d)". For example:
+ func m() (int, string, *bool, error) {
+ return
+ }
+will turn into
+ func m() (int, string, *bool, error) {
+ return 0, "", nil, nil
+ }
+
+This functionality is similar to https://github.com/sqs/goreturns.
+`
+
+var Analyzer = &analysis.Analyzer{
+ Name: "fillreturns",
+ Doc: Doc,
+ Requires: []*analysis.Analyzer{},
+ Run: run,
+ RunDespiteErrors: true,
+}
+
+var wrongReturnNumRegex = regexp.MustCompile(`wrong number of return values \(want (\d+), got (\d+)\)`)
+
+func run(pass *analysis.Pass) (interface{}, error) {
+ info := pass.TypesInfo
+ if info == nil {
+ return nil, fmt.Errorf("nil TypeInfo")
+ }
+
+ errors := analysisinternal.GetTypeErrors(pass)
+outer:
+ 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
+ }
+
+ // Get the end position of the error.
+ 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) == 0 {
+ return nil, nil
+ }
+ // Check to make sure the node of interest is a ReturnStmt.
+ ret, ok := path[0].(*ast.ReturnStmt)
+ if !ok {
+ return nil, nil
+ }
+
+ // Get the function type that encloses the ReturnStmt.
+ var enclosingFunc *ast.FuncType
+ for _, n := range path {
+ switch node := n.(type) {
+ case *ast.FuncLit:
+ enclosingFunc = node.Type
+ case *ast.FuncDecl:
+ enclosingFunc = node.Type
+ }
+ if enclosingFunc != nil {
+ break
+ }
+ }
+ if enclosingFunc == nil {
+ continue
+ }
+
+ // Find the function declaration that encloses the ReturnStmt.
+ var outer *ast.FuncDecl
+ for _, p := range path {
+ if p, ok := p.(*ast.FuncDecl); ok {
+ outer = p
+ break
+ }
+ }
+ if outer == nil {
+ return nil, nil
+ }
+
+ // Skip any return statements that contain function calls with multiple return values.
+ for _, expr := range ret.Results {
+ e, ok := expr.(*ast.CallExpr)
+ if !ok {
+ continue
+ }
+ if tup, ok := info.TypeOf(e).(*types.Tuple); ok && tup.Len() > 1 {
+ continue outer
+ }
+ }
+
+ // Duplicate the return values to track which values have been matched.
+ remaining := make([]ast.Expr, len(ret.Results))
+ copy(remaining, ret.Results)
+
+ fixed := make([]ast.Expr, len(enclosingFunc.Results.List))
+
+ // For each value in the return function declaration, find the leftmost element
+ // in the return statement that has the desired type. If no such element exits,
+ // fill in the missing value with the appropriate "zero" value.
+ var retTyps []types.Type
+ for _, ret := range enclosingFunc.Results.List {
+ retTyps = append(retTyps, info.TypeOf(ret.Type))
+ }
+ matches :=
+ analysisinternal.FindMatchingIdents(retTyps, file, ret.Pos(), info, pass.Pkg)
+ for i, retTyp := range retTyps {
+ var match ast.Expr
+ var idx int
+ for j, val := range remaining {
+ if !matchingTypes(info.TypeOf(val), retTyp) {
+ continue
+ }
+ if !analysisinternal.IsZeroValue(val) {
+ match, idx = val, j
+ break
+ }
+ // If the current match is a "zero" value, we keep searching in
+ // case we find a non-"zero" value match. If we do not find a
+ // non-"zero" value, we will use the "zero" value.
+ match, idx = val, j
+ }
+
+ if match != nil {
+ fixed[i] = match
+ remaining = append(remaining[:idx], remaining[idx+1:]...)
+ } else {
+ idents, ok := matches[retTyp]
+ if !ok {
+ return nil, fmt.Errorf("invalid return type: %v", retTyp)
+ }
+ // Find the identifer whose name is most similar to the return type.
+ // If we do not find any identifer that matches the pattern,
+ // generate a zero value.
+ value := analysisinternal.FindBestMatch(retTyp.String(), idents)
+ if value == nil {
+ value = analysisinternal.ZeroValue(
+ pass.Fset, file, pass.Pkg, retTyp)
+ }
+ if value == nil {
+ return nil, nil
+ }
+ fixed[i] = value
+ }
+ }
+
+ // Remove any non-matching "zero values" from the leftover values.
+ var nonZeroRemaining []ast.Expr
+ for _, expr := range remaining {
+ if !analysisinternal.IsZeroValue(expr) {
+ nonZeroRemaining = append(nonZeroRemaining, expr)
+ }
+ }
+ // Append leftover return values to end of new return statement.
+ fixed = append(fixed, nonZeroRemaining...)
+
+ newRet := &ast.ReturnStmt{
+ Return: ret.Pos(),
+ Results: fixed,
+ }
+
+ // Convert the new return statement AST to text.
+ var newBuf bytes.Buffer
+ if err := format.Node(&newBuf, pass.Fset, newRet); err != nil {
+ return nil, err
+ }
+
+ pass.Report(analysis.Diagnostic{
+ Pos: typeErr.Pos,
+ End: typeErrEndPos,
+ Message: typeErr.Msg,
+ SuggestedFixes: []analysis.SuggestedFix{{
+ Message: "Fill in return values",
+ TextEdits: []analysis.TextEdit{{
+ Pos: ret.Pos(),
+ End: ret.End(),
+ NewText: newBuf.Bytes(),
+ }},
+ }},
+ })
+ }
+ return nil, nil
+}
+
+func matchingTypes(want, got types.Type) bool {
+ if want == got || types.Identical(want, got) {
+ return true
+ }
+ // Code segment to help check for untyped equality from (golang/go#32146).
+ if rhs, ok := want.(*types.Basic); ok && rhs.Info()&types.IsUntyped > 0 {
+ if lhs, ok := got.Underlying().(*types.Basic); ok {
+ return rhs.Info()&types.IsConstType == lhs.Info()&types.IsConstType
+ }
+ }
+ return types.AssignableTo(want, got) || types.ConvertibleTo(want, got)
+}
+
+func FixesError(msg string) bool {
+ matches := wrongReturnNumRegex.FindStringSubmatch(strings.TrimSpace(msg))
+ if len(matches) < 3 {
+ return false
+ }
+ if _, err := strconv.Atoi(matches[1]); err != nil {
+ return false
+ }
+ if _, err := strconv.Atoi(matches[2]); err != nil {
+ return false
+ }
+ return true
+}
projects / dotfiles / .git / blobdiff