use -1 defualt value

Author: xzbdmw

go/analysis/passes/printf/printf.go

@@ -5,7 +5,6 @@
 package printf
 
 import (
-	"bytes"
 	_ "embed"
 	"fmt"
 	"go/ast"
@@ -371,6 +370,18 @@ var isPrint = stringSet{
 	"(testing.TB).Skipf":  true,
 }
 
+// stringConstantExpr returns expression's string constant value.
+//
+// ("", false) is returned if expression isn't a string
+// constant.
+func stringConstantExpr(pass *analysis.Pass, expr ast.Expr) (string, bool) {
+	lit := pass.TypesInfo.Types[expr].Value
+	if lit != nil && lit.Kind() == constant.String {
+		return constant.StringVal(lit), true
+	}
+	return "", false
+}
+
 // checkCall triggers the print-specific checks if the call invokes a print function.
 func checkCall(pass *analysis.Pass) {
 	inspect := pass.ResultOf[inspect.Analyzer].(*inspector.Inspector)
@@ -446,10 +457,10 @@ func isFormatter(typ types.Type) bool {
 		types.Identical(sig.Params().At(1).Type(), types.Typ[types.Rune])
 }
 
-// FormatStringIndex returns the index of the format string (the last
+// formatStringIndex returns the index of the format string (the last
 // non-variadic parameter) within the given printf-like call
 // expression, or -1 if unknown.
-func FormatStringIndex(info *types.Info, call *ast.CallExpr) int {
+func formatStringIndex(info *types.Info, call *ast.CallExpr) int {
 	typ := info.Types[call.Fun].Type
 	if typ == nil {
 		return -1 // missing type
@@ -473,12 +484,12 @@ func FormatStringIndex(info *types.Info, call *ast.CallExpr) int {
 
 // checkPrintf checks a call to a formatted print routine such as Printf.
 func checkPrintf(pass *analysis.Pass, kind Kind, call *ast.CallExpr, name string) {
-	idx := FormatStringIndex(pass.TypesInfo, call)
+	idx := formatStringIndex(pass.TypesInfo, call)
 	if idx < 0 || idx >= len(call.Args) {
 		return
 	}
 	formatArg := call.Args[idx]
-	format, ok := stringConstantExpr(pass.TypesInfo, formatArg)
+	format, ok := stringConstantExpr(pass, formatArg)
 	if !ok {
 		// Format string argument is non-constant.
 
@@ -518,20 +529,25 @@ func checkPrintf(pass *analysis.Pass, kind Kind, call *ast.CallExpr, name string
 	// "fmt.Sprintf call needs 1 arg but has 2 args".
 	operations, err := fmtstr.Parse(format, idx)
 	if err != nil {
+		// All error messages are in predicate form ("call has a problem")
+		// so that they may be affixed into a subject ("log.Printf ").
+		// See https://go-review.googlesource.com/c/tools/+/632598/comment/9d980373_e6460abf/
 		pass.ReportRangef(call.Args[idx], "%s %s", name, err)
 		return
 	}
 
-	maxArgIndex := firstArg
+	// index of the highest used index.
+	maxArgIndex := firstArg - 1
 	anyIndex := false
 	// Check formats against args.
 	for _, operation := range operations {
-		if operation.Prec != nil && operation.Prec.Index != -1 ||
-			operation.Width != nil && operation.Width.Index != -1 ||
+		if operation.Prec.Index != -1 ||
+			operation.Width.Index != -1 ||
 			operation.Verb.Index != -1 {
 			anyIndex = true
 		}
-		if !okPrintfArg(pass, call, &maxArgIndex, firstArg, name, operation) { // One error per format is enough.
+		if !okPrintfArg(pass, call, &maxArgIndex, firstArg, name, operation) {
+			// One error per format is enough.
 			return
 		}
 		if operation.Verb.Verb == 'w' {
@@ -543,16 +559,16 @@ func checkPrintf(pass *analysis.Pass, kind Kind, call *ast.CallExpr, name string
 		}
 	}
 	// Dotdotdot is hard.
-	if call.Ellipsis.IsValid() && maxArgIndex >= len(call.Args)-1 {
+	if call.Ellipsis.IsValid() && maxArgIndex >= len(call.Args)-2 {
 		return
 	}
 	// If any formats are indexed, extra arguments are ignored.
 	if anyIndex {
 		return
 	}
 	// There should be no leftover arguments.
-	if maxArgIndex != len(call.Args) {
-		expect := maxArgIndex - firstArg
+	if maxArgIndex+1 < len(call.Args) {
+		expect := maxArgIndex + 1 - firstArg
 		numArgs := len(call.Args) - firstArg
 		pass.ReportRangef(call, "%s call needs %v but has %v", name, count(expect, "arg"), count(numArgs, "arg"))
 	}
@@ -619,8 +635,8 @@ var printVerbs = []printVerb{
 }
 
 // okPrintfArg compares the operation to the arguments actually present,
-// reporting any discrepancies it can discern. If the final argument is ellipsissed,
-// there's little it can do for that.
+// reporting any discrepancies it can discern, maxArgIndex was the index of the highest used index.
+// If the final argument is ellipsissed, there's little it can do for that.
 func okPrintfArg(pass *analysis.Pass, call *ast.CallExpr, maxArgIndex *int, firstArg int, name string, operation *fmtstr.Operation) (ok bool) {
 	verb := operation.Verb.Verb
 	var v printVerb
@@ -662,16 +678,15 @@ func okPrintfArg(pass *analysis.Pass, call *ast.CallExpr, maxArgIndex *int, firs
 
 	var argIndexes []int
 	// First check for *.
-	if operation.Width != nil && operation.Width.Dynamic != -1 {
+	if operation.Width.Dynamic != -1 {
 		argIndexes = append(argIndexes, operation.Width.Dynamic)
 	}
-	if operation.Prec != nil && operation.Prec.Dynamic > 0 {
+	if operation.Prec.Dynamic != -1 {
 		argIndexes = append(argIndexes, operation.Prec.Dynamic)
 	}
 	// If len(argIndexes)>0, we have something like %.*s and all
 	// indexes in argIndexes must be an integer.
-	for i := 0; i < len(argIndexes); i++ {
-		argIndex := argIndexes[i]
+	for _, argIndex := range argIndexes {
 		if !argCanBeChecked(pass, call, argIndex, firstArg, operation, name) {
 			return
 		}
@@ -691,9 +706,7 @@ func okPrintfArg(pass *analysis.Pass, call *ast.CallExpr, maxArgIndex *int, firs
 		argIndexes = append(argIndexes, operation.Verb.ArgIndex)
 	}
 	for _, index := range argIndexes {
-		if index >= *maxArgIndex {
-			*maxArgIndex = index + 1
-		}
+		*maxArgIndex = max(*maxArgIndex, index)
 	}
 
 	// Special case for '%', go will print "fmt.Printf("%10.2%%dhello", 4)"
@@ -725,7 +738,7 @@ func okPrintfArg(pass *analysis.Pass, call *ast.CallExpr, maxArgIndex *int, firs
 		pass.ReportRangef(call, "%s format %s has arg %s of wrong type %s%s", name, operation.Text, analysisutil.Format(pass.Fset, arg), typeString, details)
 		return false
 	}
-	if v.typ&argString != 0 && v.verb != 'T' && !bytes.Contains(operation.Flags, []byte{'#'}) {
+	if v.typ&argString != 0 && v.verb != 'T' && !strings.Contains(operation.Flags, "#") {
 		if methodName, ok := recursiveStringer(pass, arg); ok {
 			pass.ReportRangef(call, "%s format %s with arg %s causes recursive %s method call", name, operation.Text, analysisutil.Format(pass.Fset, arg), methodName)
 			return false
@@ -886,7 +899,7 @@ func checkPrint(pass *analysis.Pass, call *ast.CallExpr, name string) {
 	}
 
 	arg := args[0]
-	if s, ok := stringConstantExpr(pass.TypesInfo, arg); ok {
+	if s, ok := stringConstantExpr(pass, arg); ok {
 		// Ignore trailing % character
 		// The % in "abc 0.0%" couldn't be a formatting directive.
 		s = strings.TrimSuffix(s, "%")
@@ -900,7 +913,7 @@ func checkPrint(pass *analysis.Pass, call *ast.CallExpr, name string) {
 	if strings.HasSuffix(name, "ln") {
 		// The last item, if a string, should not have a newline.
 		arg = args[len(args)-1]
-		if s, ok := stringConstantExpr(pass.TypesInfo, arg); ok {
+		if s, ok := stringConstantExpr(pass, arg); ok {
 			if strings.HasSuffix(s, "\n") {
 				pass.ReportRangef(call, "%s arg list ends with redundant newline", name)
 			}
@@ -916,17 +929,6 @@ func checkPrint(pass *analysis.Pass, call *ast.CallExpr, name string) {
 	}
 }
 
-// StringConstantExpr returns expression's string constant value.
-//
-// ("", false) is returned if expression isn't a string constant.
-func stringConstantExpr(info *types.Info, expr ast.Expr) (string, bool) {
-	lit := info.Types[expr].Value
-	if lit != nil && lit.Kind() == constant.String {
-		return constant.StringVal(lit), true
-	}
-	return "", false
-}
-
 // count(n, what) returns "1 what" or "N whats"
 // (assuming the plural of what is whats).
 func count(n int, what string) string {

gopls/internal/golang/codeaction.go

@@ -335,9 +335,9 @@ func quickFix(ctx context.Context, req *codeActionsRequest) error {
 				req.addApplyFixAction(msg, fixMissingCalledFunction, req.loc)
 			}
 
-		// "undeclared name: X" or "undefined: X" compiler error.
-		// Offer a "Create variable/function X" code action.
-		// See [createUndeclared] for command implementation.
+		// "undeclared name: x" or "undefined: x" compiler error.
+		// Offer a "Create variable/function x" code action.
+		// See [fixUndeclared] for command implementation.
 		case strings.HasPrefix(msg, "undeclared name: "),
 			strings.HasPrefix(msg, "undefined: "):
 			path, _ := astutil.PathEnclosingInterval(req.pgf.File, start, end)

gopls/internal/golang/fix.go

@@ -112,7 +112,7 @@ func ApplyFix(ctx context.Context, fix string, snapshot *cache.Snapshot, fh file
 		fixInvertIfCondition:       singleFile(invertIfCondition),
 		fixSplitLines:              singleFile(splitLines),
 		fixJoinLines:               singleFile(joinLines),
-		fixCreateUndeclared:        singleFile(createUndeclared),
+		fixCreateUndeclared:        singleFile(CreateUndeclared),
 		fixMissingInterfaceMethods: stubMissingInterfaceMethodsFixer,
 		fixMissingCalledFunction:   stubMissingCalledFunctionFixer,
 	}

gopls/internal/golang/undeclared.go

@@ -68,8 +68,8 @@ func undeclaredFixTitle(path []ast.Node, errMsg string) string {
 	return fmt.Sprintf("Create %s %s", noun, name)
 }
 
-// createUndeclared generates a suggested declaration for an undeclared variable or function.
-func createUndeclared(fset *token.FileSet, start, end token.Pos, content []byte, file *ast.File, pkg *types.Package, info *types.Info) (*token.FileSet, *analysis.SuggestedFix, error) {
+// CreateUndeclared generates a suggested declaration for an undeclared variable or function.
+func CreateUndeclared(fset *token.FileSet, start, end token.Pos, content []byte, file *ast.File, pkg *types.Package, info *types.Info) (*token.FileSet, *analysis.SuggestedFix, error) {
 	pos := start // don't use the end
 	path, _ := astutil.PathEnclosingInterval(file, pos, pos)
 	if len(path) < 2 {

internal/fmtstr/parse.go

@@ -16,44 +16,32 @@ import (
 // Operation holds the parsed representation of a printf operation such as "%3.*[4]d".
 // It is constructed by [Parse].
 type Operation struct {
-	Text  string // Full text of the operation, e.g. "%[2]*.3d"
-	Verb  Verb   // Verb specifier, guaranteed to exist, e.g., 'd' in '%[1]d'
-	Range Range  // The range of Text within the overall format string
-	Flags []byte // Formatting flags, e.g. ['-', '0']
-	Width *Size  // Width specifier, e.g., '3' in '%3d'
-	Prec  *Size  // Precision specifier, e.g., '.4' in '%.4f'
+	Text  string // full text of the operation, e.g. "%[2]*.3d"
+	Verb  Verb   // verb specifier, guaranteed to exist, e.g., 'd' in '%[1]d'
+	Range Range  // the range of Text within the overall format string
+	Flags string // formatting flags, e.g. "-0"
+	Width Size   // width specifier, e.g., '3' in '%3d'
+	Prec  Size   // precision specifier, e.g., '.4' in '%.4f'
 }
 
-// Internal parsing state to operation.
-type state struct {
-	operation    *Operation
-	firstArg     int  // Index of the first argument after the format string
-	argNum       int  // Which argument we're expecting to format now.
-	hasIndex     bool // Whether the argument is indexed.
-	index        int  // The encountered index
-	indexPos     int  // The encountered index's offset
-	indexPending bool // Whether we have an indexed argument that has not resolved.
-	nbytes       int  // number of bytes of the format string consumed.
-}
-
-// Size describes a width or precision in a format operation.
-// It may represent a literal number, an asterisk, or an indexed asterisk.
+// Size describes an optional width or precision in a format operation.
+// It may represent no value, a literal number, an asterisk, or an indexed asterisk.
 type Size struct {
 	// At most one of these two fields is non-negative.
-	Fixed   int // e.g. 4 from "%4d", otherwise -1.
-	Dynamic int // index of argument providing dynamic size (e.g. %*d or %[3]*d), otherwise -1.
+	Fixed   int // e.g. 4 from "%4d", otherwise -1
+	Dynamic int // index of argument providing dynamic size (e.g. %*d or %[3]*d), otherwise -1
 
-	Index int   // If the width or precision uses an indexed argument (e.g. 2 in %[2]*d), this is the index, otherwise -1.
-	Range Range // Position of the size specifier within the operation
+	Index int   // If the width or precision uses an indexed argument (e.g. 2 in %[2]*d), this is the index, otherwise -1
+	Range Range // position of the size specifier within the operation
 }
 
 // Verb represents the verb character of a format operation (e.g., 'd', 's', 'f').
 // It also includes positional information and any explicit argument indexing.
 type Verb struct {
 	Verb     rune
-	Range    Range // The positional range of the verb in the format string
-	Index    int   // The index of an indexed argument, (e.g. 2 in %[2]d), otherwise -1.
-	ArgIndex int   // The argument index (0-based) associated with this verb, relative to CallExpr.
+	Range    Range // positional range of the verb in the format string
+	Index    int   // index of an indexed argument, (e.g. 2 in %[2]d), otherwise -1
+	ArgIndex int   // argument index (0-based) associated with this verb, relative to CallExpr
 }
 
 // byte offsets of format string
@@ -105,6 +93,18 @@ func Parse(format string, idx int) ([]*Operation, error) {
 	return operations, nil
 }
 
+// Internal parsing state to operation.
+type state struct {
+	operation    *Operation
+	firstArg     int  // index of the first argument after the format string
+	argNum       int  // which argument we're expecting to format now
+	hasIndex     bool // whether the argument is indexed
+	index        int  // the encountered index
+	indexPos     int  // the encountered index's offset
+	indexPending bool // whether we have an indexed argument that has not resolved
+	nbytes       int  // number of bytes of the format string consumed
+}
+
 // parseOperation parses one format operation starting at the given substring `format`,
 // which should begin with '%'. It returns a fully populated state or an error
 // if the operation is malformed. The firstArg and argNum parameters help determine how
@@ -114,8 +114,17 @@ func Parse(format string, idx int) ([]*Operation, error) {
 func parseOperation(format string, firstArg, argNum int) (*state, error) {
 	state := &state{
 		operation: &Operation{
-			Text:  format,
-			Flags: make([]byte, 0),
+			Text: format,
+			Width: Size{
+				Fixed:   -1,
+				Dynamic: -1,
+				Index:   -1,
+			},
+			Prec: Size{
+				Fixed:   -1,
+				Dynamic: -1,
+				Index:   -1,
+			},
 		},
 		firstArg:     firstArg,
 		argNum:       argNum,
@@ -184,27 +193,28 @@ func (s *Operation) addOffset(parsedLen int) {
 
 	s.Range.Start = parsedLen
 	s.Range.End = s.Verb.Range.End
-	if s.Prec != nil {
+
+	// one of Fixed or Dynamic is non-negative means existence.
+	if s.Prec.Fixed == -1 && s.Prec.Dynamic == -1 {
 		s.Prec.Range.Start += parsedLen
 		s.Prec.Range.End += parsedLen
 	}
-	if s.Width != nil {
+	if s.Width.Fixed == -1 && s.Width.Dynamic == -1 {
 		s.Width.Range.Start += parsedLen
 		s.Width.Range.End += parsedLen
 	}
 }
 
 // parseFlags accepts any printf flags.
 func (s *state) parseFlags() {
-	for s.nbytes < len(s.operation.Text) {
-		switch c := s.operation.Text[s.nbytes]; c {
-		case '#', '0', '+', '-', ' ':
-			s.operation.Flags = append(s.operation.Flags, c)
-			s.nbytes++
-		default:
-			return
-		}
-	}
+	s.operation.Flags = prefixOf(s.operation.Text[s.nbytes:], "#0+- ")
+	s.nbytes += len(s.operation.Flags)
+}
+
+// prefixOf returns the prefix of s composed only of runes from the specified set.
+func prefixOf(s, set string) string {
+	rest := strings.TrimLeft(s, set)
+	return s[:len(s)-len(rest)]
 }
 
 // parseIndex parses an argument index of the form "[n]" that can appear
@@ -278,7 +288,7 @@ func (s *state) parseSize(kind sizeType) {
 		if s.indexPending {
 			// Absorb it.
 			s.indexPending = false
-			size := &Size{
+			size := Size{
 				Fixed:   -1,
 				Dynamic: s.argNum,
 				Index:   s.index,
@@ -299,7 +309,7 @@ func (s *state) parseSize(kind sizeType) {
 			}
 		} else {
 			// Non-indexed asterisk: "%*d".
-			size := &Size{
+			size := Size{
 				Dynamic: s.argNum,
 				Index:   -1,
 				Fixed:   -1,
@@ -323,7 +333,7 @@ func (s *state) parseSize(kind sizeType) {
 	} else { // Literal number, e.g. "%10d"
 		start := s.nbytes
 		if num, ok := s.scanNum(); ok {
-			size := &Size{
+			size := Size{
 				Fixed:   num,
 				Index:   -1,
 				Dynamic: -1,