| // Copyright 2010 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. |
| |
| // This file contains the printf-checker. |
| |
| package main |
| |
| import ( |
| "bytes" |
| "flag" |
| "fmt" |
| "go/ast" |
| "go/constant" |
| "go/token" |
| "go/types" |
| "regexp" |
| "strconv" |
| "strings" |
| "unicode/utf8" |
| ) |
| |
| var printfuncs = flag.String("printfuncs", "", "comma-separated list of print function names to check") |
| |
| func init() { |
| register("printf", |
| "check printf-like invocations", |
| checkFmtPrintfCall, |
| funcDecl, callExpr) |
| } |
| |
| func initPrintFlags() { |
| if *printfuncs == "" { |
| return |
| } |
| for _, name := range strings.Split(*printfuncs, ",") { |
| if len(name) == 0 { |
| flag.Usage() |
| } |
| |
| // Backwards compatibility: skip optional first argument |
| // index after the colon. |
| if colon := strings.LastIndex(name, ":"); colon > 0 { |
| name = name[:colon] |
| } |
| |
| isPrint[strings.ToLower(name)] = true |
| } |
| } |
| |
| // TODO(rsc): Incorporate user-defined printf wrappers again. |
| // The general plan is to allow vet of one package P to output |
| // additional information to supply to later vets of packages |
| // importing P. Then vet of P can record a list of printf wrappers |
| // and the later vet using P.Printf will find it in the list and check it. |
| // That's not ready for Go 1.10. |
| // When that does happen, uncomment the user-defined printf |
| // wrapper tests in testdata/print.go. |
| |
| // isPrint records the print functions. |
| // If a key ends in 'f' then it is assumed to be a formatted print. |
| var isPrint = map[string]bool{ |
| "fmt.Errorf": true, |
| "fmt.Fprint": true, |
| "fmt.Fprintf": true, |
| "fmt.Fprintln": true, |
| "fmt.Print": true, |
| "fmt.Printf": true, |
| "fmt.Println": true, |
| "fmt.Sprint": true, |
| "fmt.Sprintf": true, |
| "fmt.Sprintln": true, |
| "log.Fatal": true, |
| "log.Fatalf": true, |
| "log.Fatalln": true, |
| "log.Logger.Fatal": true, |
| "log.Logger.Fatalf": true, |
| "log.Logger.Fatalln": true, |
| "log.Logger.Panic": true, |
| "log.Logger.Panicf": true, |
| "log.Logger.Panicln": true, |
| "log.Logger.Printf": true, |
| "log.Logger.Println": true, |
| "log.Panic": true, |
| "log.Panicf": true, |
| "log.Panicln": true, |
| "log.Print": true, |
| "log.Printf": true, |
| "log.Println": true, |
| "testing.B.Error": true, |
| "testing.B.Errorf": true, |
| "testing.B.Fatal": true, |
| "testing.B.Fatalf": true, |
| "testing.B.Log": true, |
| "testing.B.Logf": true, |
| "testing.B.Skip": true, |
| "testing.B.Skipf": true, |
| "testing.T.Error": true, |
| "testing.T.Errorf": true, |
| "testing.T.Fatal": true, |
| "testing.T.Fatalf": true, |
| "testing.T.Log": true, |
| "testing.T.Logf": true, |
| "testing.T.Skip": true, |
| "testing.T.Skipf": true, |
| "testing.TB.Error": true, |
| "testing.TB.Errorf": true, |
| "testing.TB.Fatal": true, |
| "testing.TB.Fatalf": true, |
| "testing.TB.Log": true, |
| "testing.TB.Logf": true, |
| "testing.TB.Skip": true, |
| "testing.TB.Skipf": true, |
| } |
| |
| // formatString returns the format string argument and its index within |
| // the given printf-like call expression. |
| // |
| // The last parameter before variadic arguments is assumed to be |
| // a format string. |
| // |
| // The first string literal or string constant is assumed to be a format string |
| // if the call's signature cannot be determined. |
| // |
| // If it cannot find any format string parameter, it returns ("", -1). |
| func formatString(f *File, call *ast.CallExpr) (format string, idx int) { |
| typ := f.pkg.types[call.Fun].Type |
| if typ != nil { |
| if sig, ok := typ.(*types.Signature); ok { |
| if !sig.Variadic() { |
| // Skip checking non-variadic functions. |
| return "", -1 |
| } |
| idx := sig.Params().Len() - 2 |
| if idx < 0 { |
| // Skip checking variadic functions without |
| // fixed arguments. |
| return "", -1 |
| } |
| s, ok := stringConstantArg(f, call, idx) |
| if !ok { |
| // The last argument before variadic args isn't a string. |
| return "", -1 |
| } |
| return s, idx |
| } |
| } |
| |
| // Cannot determine call's signature. Fall back to scanning for the first |
| // string constant in the call. |
| for idx := range call.Args { |
| if s, ok := stringConstantArg(f, call, idx); ok { |
| return s, idx |
| } |
| if f.pkg.types[call.Args[idx]].Type == types.Typ[types.String] { |
| // Skip checking a call with a non-constant format |
| // string argument, since its contents are unavailable |
| // for validation. |
| return "", -1 |
| } |
| } |
| return "", -1 |
| } |
| |
| // stringConstantArg returns call's string constant argument at the index idx. |
| // |
| // ("", false) is returned if call's argument at the index idx isn't a string |
| // constant. |
| func stringConstantArg(f *File, call *ast.CallExpr, idx int) (string, bool) { |
| if idx >= len(call.Args) { |
| return "", false |
| } |
| arg := call.Args[idx] |
| lit := f.pkg.types[arg].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 checkFmtPrintfCall(f *File, node ast.Node) { |
| if f.pkg.typesPkg == nil { |
| // This check now requires type information. |
| return |
| } |
| |
| if d, ok := node.(*ast.FuncDecl); ok && isStringer(f, d) { |
| // Remember we saw this. |
| if f.stringerPtrs == nil { |
| f.stringerPtrs = make(map[*ast.Object]bool) |
| } |
| if l := d.Recv.List; len(l) == 1 { |
| if n := l[0].Names; len(n) == 1 { |
| typ := f.pkg.types[l[0].Type] |
| _, ptrRecv := typ.Type.(*types.Pointer) |
| f.stringerPtrs[n[0].Obj] = ptrRecv |
| } |
| } |
| return |
| } |
| |
| call, ok := node.(*ast.CallExpr) |
| if !ok { |
| return |
| } |
| |
| // Construct name like pkg.Printf or pkg.Type.Printf for lookup. |
| var name string |
| switch x := call.Fun.(type) { |
| case *ast.Ident: |
| if fn, ok := f.pkg.uses[x].(*types.Func); ok { |
| var pkg string |
| if fn.Pkg() == nil || fn.Pkg() == f.pkg.typesPkg { |
| pkg = vcfg.ImportPath |
| } else { |
| pkg = fn.Pkg().Path() |
| } |
| name = pkg + "." + x.Name |
| break |
| } |
| |
| case *ast.SelectorExpr: |
| // Check for "fmt.Printf". |
| if id, ok := x.X.(*ast.Ident); ok { |
| if pkgName, ok := f.pkg.uses[id].(*types.PkgName); ok { |
| name = pkgName.Imported().Path() + "." + x.Sel.Name |
| break |
| } |
| } |
| |
| // Check for t.Logf where t is a *testing.T. |
| if sel := f.pkg.selectors[x]; sel != nil { |
| recv := sel.Recv() |
| if p, ok := recv.(*types.Pointer); ok { |
| recv = p.Elem() |
| } |
| if named, ok := recv.(*types.Named); ok { |
| obj := named.Obj() |
| var pkg string |
| if obj.Pkg() == nil || obj.Pkg() == f.pkg.typesPkg { |
| pkg = vcfg.ImportPath |
| } else { |
| pkg = obj.Pkg().Path() |
| } |
| name = pkg + "." + obj.Name() + "." + x.Sel.Name |
| break |
| } |
| } |
| } |
| if name == "" { |
| return |
| } |
| |
| shortName := name[strings.LastIndex(name, ".")+1:] |
| |
| _, ok = isPrint[name] |
| if !ok { |
| // Next look up just "printf", for use with -printfuncs. |
| _, ok = isPrint[strings.ToLower(shortName)] |
| } |
| if ok { |
| if strings.HasSuffix(name, "f") { |
| f.checkPrintf(call, shortName) |
| } else { |
| f.checkPrint(call, shortName) |
| } |
| } |
| } |
| |
| // isStringer returns true if the provided declaration is a "String() string" |
| // method, an implementation of fmt.Stringer. |
| func isStringer(f *File, d *ast.FuncDecl) bool { |
| return d.Recv != nil && d.Name.Name == "String" && d.Type.Results != nil && |
| len(d.Type.Params.List) == 0 && len(d.Type.Results.List) == 1 && |
| f.pkg.types[d.Type.Results.List[0].Type].Type == types.Typ[types.String] |
| } |
| |
| // isFormatter reports whether t satisfies fmt.Formatter. |
| // Unlike fmt.Stringer, it's impossible to satisfy fmt.Formatter without importing fmt. |
| func (f *File) isFormatter(t types.Type) bool { |
| return formatterType != nil && types.Implements(t, formatterType) |
| } |
| |
| // formatState holds the parsed representation of a printf directive such as "%3.*[4]d". |
| // It is constructed by parsePrintfVerb. |
| type formatState struct { |
| verb rune // the format verb: 'd' for "%d" |
| format string // the full format directive from % through verb, "%.3d". |
| name string // Printf, Sprintf etc. |
| flags []byte // the list of # + etc. |
| argNums []int // the successive argument numbers that are consumed, adjusted to refer to actual arg in call |
| firstArg int // Index of first argument after the format in the Printf call. |
| // Used only during parse. |
| file *File |
| call *ast.CallExpr |
| argNum int // Which argument we're expecting to format now. |
| hasIndex bool // Whether the argument is indexed. |
| indexPending bool // Whether we have an indexed argument that has not resolved. |
| nbytes int // number of bytes of the format string consumed. |
| } |
| |
| // checkPrintf checks a call to a formatted print routine such as Printf. |
| func (f *File) checkPrintf(call *ast.CallExpr, name string) { |
| format, idx := formatString(f, call) |
| if idx < 0 { |
| if *verbose { |
| f.Warn(call.Pos(), "can't check non-constant format in call to", name) |
| } |
| return |
| } |
| |
| firstArg := idx + 1 // Arguments are immediately after format string. |
| if !strings.Contains(format, "%") { |
| if len(call.Args) > firstArg { |
| f.Badf(call.Pos(), "%s call has arguments but no formatting directives", name) |
| } |
| return |
| } |
| // Hard part: check formats against args. |
| argNum := firstArg |
| maxArgNum := firstArg |
| anyIndex := false |
| for i, w := 0, 0; i < len(format); i += w { |
| w = 1 |
| if format[i] != '%' { |
| continue |
| } |
| state := f.parsePrintfVerb(call, name, format[i:], firstArg, argNum) |
| if state == nil { |
| return |
| } |
| w = len(state.format) |
| if !f.okPrintfArg(call, state) { // One error per format is enough. |
| return |
| } |
| if state.hasIndex { |
| anyIndex = true |
| } |
| if len(state.argNums) > 0 { |
| // Continue with the next sequential argument. |
| argNum = state.argNums[len(state.argNums)-1] + 1 |
| } |
| for _, n := range state.argNums { |
| if n >= maxArgNum { |
| maxArgNum = n + 1 |
| } |
| } |
| } |
| // Dotdotdot is hard. |
| if call.Ellipsis.IsValid() && maxArgNum >= len(call.Args)-1 { |
| return |
| } |
| // If any formats are indexed, extra arguments are ignored. |
| if anyIndex { |
| return |
| } |
| // There should be no leftover arguments. |
| if maxArgNum != len(call.Args) { |
| expect := maxArgNum - firstArg |
| numArgs := len(call.Args) - firstArg |
| f.Badf(call.Pos(), "%s call needs %v but has %v", name, count(expect, "arg"), count(numArgs, "arg")) |
| } |
| } |
| |
| // parseFlags accepts any printf flags. |
| func (s *formatState) parseFlags() { |
| for s.nbytes < len(s.format) { |
| switch c := s.format[s.nbytes]; c { |
| case '#', '0', '+', '-', ' ': |
| s.flags = append(s.flags, c) |
| s.nbytes++ |
| default: |
| return |
| } |
| } |
| } |
| |
| // scanNum advances through a decimal number if present. |
| func (s *formatState) scanNum() { |
| for ; s.nbytes < len(s.format); s.nbytes++ { |
| c := s.format[s.nbytes] |
| if c < '0' || '9' < c { |
| return |
| } |
| } |
| } |
| |
| // parseIndex scans an index expression. It returns false if there is a syntax error. |
| func (s *formatState) parseIndex() bool { |
| if s.nbytes == len(s.format) || s.format[s.nbytes] != '[' { |
| return true |
| } |
| // Argument index present. |
| s.nbytes++ // skip '[' |
| start := s.nbytes |
| s.scanNum() |
| ok := true |
| if s.nbytes == len(s.format) || s.nbytes == start || s.format[s.nbytes] != ']' { |
| ok = false |
| s.nbytes = strings.Index(s.format, "]") |
| if s.nbytes < 0 { |
| s.file.Badf(s.call.Pos(), "%s format %s is missing closing ]", s.name, s.format) |
| return false |
| } |
| } |
| arg32, err := strconv.ParseInt(s.format[start:s.nbytes], 10, 32) |
| if err != nil || !ok || arg32 <= 0 || arg32 > int64(len(s.call.Args)-s.firstArg) { |
| s.file.Badf(s.call.Pos(), "%s format has invalid argument index [%s]", s.name, s.format[start:s.nbytes]) |
| return false |
| } |
| s.nbytes++ // skip ']' |
| arg := int(arg32) |
| arg += s.firstArg - 1 // We want to zero-index the actual arguments. |
| s.argNum = arg |
| s.hasIndex = true |
| s.indexPending = true |
| return true |
| } |
| |
| // parseNum scans a width or precision (or *). It returns false if there's a bad index expression. |
| func (s *formatState) parseNum() bool { |
| if s.nbytes < len(s.format) && s.format[s.nbytes] == '*' { |
| if s.indexPending { // Absorb it. |
| s.indexPending = false |
| } |
| s.nbytes++ |
| s.argNums = append(s.argNums, s.argNum) |
| s.argNum++ |
| } else { |
| s.scanNum() |
| } |
| return true |
| } |
| |
| // parsePrecision scans for a precision. It returns false if there's a bad index expression. |
| func (s *formatState) parsePrecision() bool { |
| // If there's a period, there may be a precision. |
| if s.nbytes < len(s.format) && s.format[s.nbytes] == '.' { |
| s.flags = append(s.flags, '.') // Treat precision as a flag. |
| s.nbytes++ |
| if !s.parseIndex() { |
| return false |
| } |
| if !s.parseNum() { |
| return false |
| } |
| } |
| return true |
| } |
| |
| // parsePrintfVerb looks the formatting directive that begins the format string |
| // and returns a formatState that encodes what the directive wants, without looking |
| // at the actual arguments present in the call. The result is nil if there is an error. |
| func (f *File) parsePrintfVerb(call *ast.CallExpr, name, format string, firstArg, argNum int) *formatState { |
| state := &formatState{ |
| format: format, |
| name: name, |
| flags: make([]byte, 0, 5), |
| argNum: argNum, |
| argNums: make([]int, 0, 1), |
| nbytes: 1, // There's guaranteed to be a percent sign. |
| firstArg: firstArg, |
| file: f, |
| call: call, |
| } |
| // There may be flags. |
| state.parseFlags() |
| // There may be an index. |
| if !state.parseIndex() { |
| return nil |
| } |
| // There may be a width. |
| if !state.parseNum() { |
| return nil |
| } |
| // There may be a precision. |
| if !state.parsePrecision() { |
| return nil |
| } |
| // Now a verb, possibly prefixed by an index (which we may already have). |
| if !state.indexPending && !state.parseIndex() { |
| return nil |
| } |
| if state.nbytes == len(state.format) { |
| f.Badf(call.Pos(), "%s format %s is missing verb at end of string", name, state.format) |
| return nil |
| } |
| verb, w := utf8.DecodeRuneInString(state.format[state.nbytes:]) |
| state.verb = verb |
| state.nbytes += w |
| if verb != '%' { |
| state.argNums = append(state.argNums, state.argNum) |
| } |
| state.format = state.format[:state.nbytes] |
| return state |
| } |
| |
| // printfArgType encodes the types of expressions a printf verb accepts. It is a bitmask. |
| type printfArgType int |
| |
| const ( |
| argBool printfArgType = 1 << iota |
| argInt |
| argRune |
| argString |
| argFloat |
| argComplex |
| argPointer |
| anyType printfArgType = ^0 |
| ) |
| |
| type printVerb struct { |
| verb rune // User may provide verb through Formatter; could be a rune. |
| flags string // known flags are all ASCII |
| typ printfArgType |
| } |
| |
| // Common flag sets for printf verbs. |
| const ( |
| noFlag = "" |
| numFlag = " -+.0" |
| sharpNumFlag = " -+.0#" |
| allFlags = " -+.0#" |
| ) |
| |
| // printVerbs identifies which flags are known to printf for each verb. |
| var printVerbs = []printVerb{ |
| // '-' is a width modifier, always valid. |
| // '.' is a precision for float, max width for strings. |
| // '+' is required sign for numbers, Go format for %v. |
| // '#' is alternate format for several verbs. |
| // ' ' is spacer for numbers |
| {'%', noFlag, 0}, |
| {'b', numFlag, argInt | argFloat | argComplex}, |
| {'c', "-", argRune | argInt}, |
| {'d', numFlag, argInt}, |
| {'e', sharpNumFlag, argFloat | argComplex}, |
| {'E', sharpNumFlag, argFloat | argComplex}, |
| {'f', sharpNumFlag, argFloat | argComplex}, |
| {'F', sharpNumFlag, argFloat | argComplex}, |
| {'g', sharpNumFlag, argFloat | argComplex}, |
| {'G', sharpNumFlag, argFloat | argComplex}, |
| {'o', sharpNumFlag, argInt}, |
| {'p', "-#", argPointer}, |
| {'q', " -+.0#", argRune | argInt | argString}, |
| {'s', " -+.0", argString}, |
| {'t', "-", argBool}, |
| {'T', "-", anyType}, |
| {'U', "-#", argRune | argInt}, |
| {'v', allFlags, anyType}, |
| {'x', sharpNumFlag, argRune | argInt | argString}, |
| {'X', sharpNumFlag, argRune | argInt | argString}, |
| } |
| |
| // okPrintfArg compares the formatState 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. |
| func (f *File) okPrintfArg(call *ast.CallExpr, state *formatState) (ok bool) { |
| var v printVerb |
| found := false |
| // Linear scan is fast enough for a small list. |
| for _, v = range printVerbs { |
| if v.verb == state.verb { |
| found = true |
| break |
| } |
| } |
| |
| // Does current arg implement fmt.Formatter? |
| formatter := false |
| if state.argNum < len(call.Args) { |
| if tv, ok := f.pkg.types[call.Args[state.argNum]]; ok { |
| formatter = f.isFormatter(tv.Type) |
| } |
| } |
| |
| if !formatter { |
| if !found { |
| f.Badf(call.Pos(), "%s format %s has unknown verb %c", state.name, state.format, state.verb) |
| return false |
| } |
| for _, flag := range state.flags { |
| // TODO: Disable complaint about '0' for Go 1.10. To be fixed properly in 1.11. |
| // See issues 23598 and 23605. |
| if flag == '0' { |
| continue |
| } |
| if !strings.ContainsRune(v.flags, rune(flag)) { |
| f.Badf(call.Pos(), "%s format %s has unrecognized flag %c", state.name, state.format, flag) |
| return false |
| } |
| } |
| } |
| // Verb is good. If len(state.argNums)>trueArgs, we have something like %.*s and all |
| // but the final arg must be an integer. |
| trueArgs := 1 |
| if state.verb == '%' { |
| trueArgs = 0 |
| } |
| nargs := len(state.argNums) |
| for i := 0; i < nargs-trueArgs; i++ { |
| argNum := state.argNums[i] |
| if !f.argCanBeChecked(call, i, state) { |
| return |
| } |
| arg := call.Args[argNum] |
| if !f.matchArgType(argInt, nil, arg) { |
| f.Badf(call.Pos(), "%s format %s uses non-int %s as argument of *", state.name, state.format, f.gofmt(arg)) |
| return false |
| } |
| } |
| if state.verb == '%' || formatter { |
| return true |
| } |
| argNum := state.argNums[len(state.argNums)-1] |
| if !f.argCanBeChecked(call, len(state.argNums)-1, state) { |
| return false |
| } |
| arg := call.Args[argNum] |
| if f.isFunctionValue(arg) && state.verb != 'p' && state.verb != 'T' { |
| f.Badf(call.Pos(), "%s format %s arg %s is a func value, not called", state.name, state.format, f.gofmt(arg)) |
| return false |
| } |
| if !f.matchArgType(v.typ, nil, arg) { |
| typeString := "" |
| if typ := f.pkg.types[arg].Type; typ != nil { |
| typeString = typ.String() |
| } |
| f.Badf(call.Pos(), "%s format %s has arg %s of wrong type %s", state.name, state.format, f.gofmt(arg), typeString) |
| return false |
| } |
| if v.typ&argString != 0 && v.verb != 'T' && !bytes.Contains(state.flags, []byte{'#'}) && f.recursiveStringer(arg) { |
| f.Badf(call.Pos(), "%s format %s with arg %s causes recursive String method call", state.name, state.format, f.gofmt(arg)) |
| return false |
| } |
| return true |
| } |
| |
| // recursiveStringer reports whether the provided argument is r or &r for the |
| // fmt.Stringer receiver identifier r. |
| func (f *File) recursiveStringer(e ast.Expr) bool { |
| if len(f.stringerPtrs) == 0 { |
| return false |
| } |
| ptr := false |
| var obj *ast.Object |
| switch e := e.(type) { |
| case *ast.Ident: |
| obj = e.Obj |
| case *ast.UnaryExpr: |
| if id, ok := e.X.(*ast.Ident); ok && e.Op == token.AND { |
| obj = id.Obj |
| ptr = true |
| } |
| } |
| |
| // It's unlikely to be a recursive stringer if it has a Format method. |
| if typ := f.pkg.types[e].Type; typ != nil { |
| if f.isFormatter(typ) { |
| return false |
| } |
| } |
| |
| // We compare the underlying Object, which checks that the identifier |
| // is the one we declared as the receiver for the String method in |
| // which this printf appears. |
| ptrRecv, exist := f.stringerPtrs[obj] |
| if !exist { |
| return false |
| } |
| // We also need to check that using &t when we declared String |
| // on (t *T) is ok; in such a case, the address is printed. |
| if ptr && ptrRecv { |
| return false |
| } |
| return true |
| } |
| |
| // isFunctionValue reports whether the expression is a function as opposed to a function call. |
| // It is almost always a mistake to print a function value. |
| func (f *File) isFunctionValue(e ast.Expr) bool { |
| if typ := f.pkg.types[e].Type; typ != nil { |
| _, ok := typ.(*types.Signature) |
| return ok |
| } |
| return false |
| } |
| |
| // argCanBeChecked reports whether the specified argument is statically present; |
| // it may be beyond the list of arguments or in a terminal slice... argument, which |
| // means we can't see it. |
| func (f *File) argCanBeChecked(call *ast.CallExpr, formatArg int, state *formatState) bool { |
| argNum := state.argNums[formatArg] |
| if argNum <= 0 { |
| // Shouldn't happen, so catch it with prejudice. |
| panic("negative arg num") |
| } |
| if argNum < len(call.Args)-1 { |
| return true // Always OK. |
| } |
| if call.Ellipsis.IsValid() { |
| return false // We just can't tell; there could be many more arguments. |
| } |
| if argNum < len(call.Args) { |
| return true |
| } |
| // There are bad indexes in the format or there are fewer arguments than the format needs. |
| // This is the argument number relative to the format: Printf("%s", "hi") will give 1 for the "hi". |
| arg := argNum - state.firstArg + 1 // People think of arguments as 1-indexed. |
| f.Badf(call.Pos(), "%s format %s reads arg #%d, but call has only %v", state.name, state.format, arg, count(len(call.Args)-state.firstArg, "arg")) |
| return false |
| } |
| |
| // printFormatRE is the regexp we match and report as a possible format string |
| // in the first argument to unformatted prints like fmt.Print. |
| // We exclude the space flag, so that printing a string like "x % y" is not reported as a format. |
| var printFormatRE = regexp.MustCompile(`%` + flagsRE + numOptRE + `\.?` + numOptRE + indexOptRE + verbRE) |
| |
| const ( |
| flagsRE = `[+\-#]*` |
| indexOptRE = `(\[[0-9]+\])?` |
| numOptRE = `([0-9]+|` + indexOptRE + `\*)?` |
| verbRE = `[bcdefgopqstvxEFGUX]` |
| ) |
| |
| // checkPrint checks a call to an unformatted print routine such as Println. |
| func (f *File) checkPrint(call *ast.CallExpr, name string) { |
| firstArg := 0 |
| typ := f.pkg.types[call.Fun].Type |
| if typ == nil { |
| // Skip checking functions with unknown type. |
| return |
| } |
| if sig, ok := typ.(*types.Signature); ok { |
| if !sig.Variadic() { |
| // Skip checking non-variadic functions. |
| return |
| } |
| params := sig.Params() |
| firstArg = params.Len() - 1 |
| |
| typ := params.At(firstArg).Type() |
| typ = typ.(*types.Slice).Elem() |
| it, ok := typ.(*types.Interface) |
| if !ok || !it.Empty() { |
| // Skip variadic functions accepting non-interface{} args. |
| return |
| } |
| } |
| args := call.Args |
| if len(args) <= firstArg { |
| // Skip calls without variadic args. |
| return |
| } |
| args = args[firstArg:] |
| |
| if firstArg == 0 { |
| if sel, ok := call.Args[0].(*ast.SelectorExpr); ok { |
| if x, ok := sel.X.(*ast.Ident); ok { |
| if x.Name == "os" && strings.HasPrefix(sel.Sel.Name, "Std") { |
| f.Badf(call.Pos(), "%s does not take io.Writer but has first arg %s", name, f.gofmt(call.Args[0])) |
| } |
| } |
| } |
| } |
| |
| arg := args[0] |
| if lit, ok := arg.(*ast.BasicLit); ok && lit.Kind == token.STRING { |
| // Ignore trailing % character in lit.Value. |
| // The % in "abc 0.0%" couldn't be a formatting directive. |
| s := strings.TrimSuffix(lit.Value, `%"`) |
| if strings.Contains(s, "%") { |
| m := printFormatRE.FindStringSubmatch(s) |
| if m != nil { |
| f.Badf(call.Pos(), "%s call has possible formatting directive %s", name, m[0]) |
| } |
| } |
| } |
| if strings.HasSuffix(name, "ln") { |
| // The last item, if a string, should not have a newline. |
| arg = args[len(args)-1] |
| if lit, ok := arg.(*ast.BasicLit); ok && lit.Kind == token.STRING { |
| str, _ := strconv.Unquote(lit.Value) |
| if strings.HasSuffix(str, "\n") { |
| f.Badf(call.Pos(), "%s arg list ends with redundant newline", name) |
| } |
| } |
| } |
| for _, arg := range args { |
| if f.isFunctionValue(arg) { |
| f.Badf(call.Pos(), "%s arg %s is a func value, not called", name, f.gofmt(arg)) |
| } |
| if f.recursiveStringer(arg) { |
| f.Badf(call.Pos(), "%s arg %s causes recursive call to String method", name, f.gofmt(arg)) |
| } |
| } |
| } |
| |
| // count(n, what) returns "1 what" or "N whats" |
| // (assuming the plural of what is whats). |
| func count(n int, what string) string { |
| if n == 1 { |
| return "1 " + what |
| } |
| return fmt.Sprintf("%d %ss", n, what) |
| } |