--- /dev/null
+// 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.
+
+// Package printf defines an Analyzer that checks consistency
+// of Printf format strings and arguments.
+package printf
+
+import (
+ "bytes"
+ "fmt"
+ "go/ast"
+ "go/constant"
+ "go/token"
+ "go/types"
+ "reflect"
+ "regexp"
+ "sort"
+ "strconv"
+ "strings"
+ "unicode/utf8"
+
+ "golang.org/x/tools/go/analysis"
+ "golang.org/x/tools/go/analysis/passes/inspect"
+ "golang.org/x/tools/go/analysis/passes/internal/analysisutil"
+ "golang.org/x/tools/go/ast/inspector"
+ "golang.org/x/tools/go/types/typeutil"
+)
+
+func init() {
+ Analyzer.Flags.Var(isPrint, "funcs", "comma-separated list of print function names to check")
+}
+
+var Analyzer = &analysis.Analyzer{
+ Name: "printf",
+ Doc: Doc,
+ Requires: []*analysis.Analyzer{inspect.Analyzer},
+ Run: run,
+ ResultType: reflect.TypeOf((*Result)(nil)),
+ FactTypes: []analysis.Fact{new(isWrapper)},
+}
+
+const Doc = `check consistency of Printf format strings and arguments
+
+The check applies to known functions (for example, those in package fmt)
+as well as any detected wrappers of known functions.
+
+A function that wants to avail itself of printf checking but is not
+found by this analyzer's heuristics (for example, due to use of
+dynamic calls) can insert a bogus call:
+
+ if false {
+ _ = fmt.Sprintf(format, args...) // enable printf checking
+ }
+
+The -funcs flag specifies a comma-separated list of names of additional
+known formatting functions or methods. If the name contains a period,
+it must denote a specific function using one of the following forms:
+
+ dir/pkg.Function
+ dir/pkg.Type.Method
+ (*dir/pkg.Type).Method
+
+Otherwise the name is interpreted as a case-insensitive unqualified
+identifier such as "errorf". Either way, if a listed name ends in f, the
+function is assumed to be Printf-like, taking a format string before the
+argument list. Otherwise it is assumed to be Print-like, taking a list
+of arguments with no format string.
+`
+
+// Kind is a kind of fmt function behavior.
+type Kind int
+
+const (
+ KindNone Kind = iota // not a fmt wrapper function
+ KindPrint // function behaves like fmt.Print
+ KindPrintf // function behaves like fmt.Printf
+ KindErrorf // function behaves like fmt.Errorf
+)
+
+func (kind Kind) String() string {
+ switch kind {
+ case KindPrint:
+ return "print"
+ case KindPrintf:
+ return "printf"
+ case KindErrorf:
+ return "errorf"
+ }
+ return ""
+}
+
+// Result is the printf analyzer's result type. Clients may query the result
+// to learn whether a function behaves like fmt.Print or fmt.Printf.
+type Result struct {
+ funcs map[*types.Func]Kind
+}
+
+// Kind reports whether fn behaves like fmt.Print or fmt.Printf.
+func (r *Result) Kind(fn *types.Func) Kind {
+ _, ok := isPrint[fn.FullName()]
+ if !ok {
+ // Next look up just "printf", for use with -printf.funcs.
+ _, ok = isPrint[strings.ToLower(fn.Name())]
+ }
+ if ok {
+ if strings.HasSuffix(fn.Name(), "f") {
+ return KindPrintf
+ } else {
+ return KindPrint
+ }
+ }
+
+ return r.funcs[fn]
+}
+
+// isWrapper is a fact indicating that a function is a print or printf wrapper.
+type isWrapper struct{ Kind Kind }
+
+func (f *isWrapper) AFact() {}
+
+func (f *isWrapper) String() string {
+ switch f.Kind {
+ case KindPrintf:
+ return "printfWrapper"
+ case KindPrint:
+ return "printWrapper"
+ case KindErrorf:
+ return "errorfWrapper"
+ default:
+ return "unknownWrapper"
+ }
+}
+
+func run(pass *analysis.Pass) (interface{}, error) {
+ res := &Result{
+ funcs: make(map[*types.Func]Kind),
+ }
+ findPrintfLike(pass, res)
+ checkCall(pass)
+ return res, nil
+}
+
+type printfWrapper struct {
+ obj *types.Func
+ fdecl *ast.FuncDecl
+ format *types.Var
+ args *types.Var
+ callers []printfCaller
+ failed bool // if true, not a printf wrapper
+}
+
+type printfCaller struct {
+ w *printfWrapper
+ call *ast.CallExpr
+}
+
+// maybePrintfWrapper decides whether decl (a declared function) may be a wrapper
+// around a fmt.Printf or fmt.Print function. If so it returns a printfWrapper
+// function describing the declaration. Later processing will analyze the
+// graph of potential printf wrappers to pick out the ones that are true wrappers.
+// A function may be a Printf or Print wrapper if its last argument is ...interface{}.
+// If the next-to-last argument is a string, then this may be a Printf wrapper.
+// Otherwise it may be a Print wrapper.
+func maybePrintfWrapper(info *types.Info, decl ast.Decl) *printfWrapper {
+ // Look for functions with final argument type ...interface{}.
+ fdecl, ok := decl.(*ast.FuncDecl)
+ if !ok || fdecl.Body == nil {
+ return nil
+ }
+ fn, ok := info.Defs[fdecl.Name].(*types.Func)
+ // Type information may be incomplete.
+ if !ok {
+ return nil
+ }
+
+ sig := fn.Type().(*types.Signature)
+ if !sig.Variadic() {
+ return nil // not variadic
+ }
+
+ params := sig.Params()
+ nparams := params.Len() // variadic => nonzero
+
+ args := params.At(nparams - 1)
+ iface, ok := args.Type().(*types.Slice).Elem().(*types.Interface)
+ if !ok || !iface.Empty() {
+ return nil // final (args) param is not ...interface{}
+ }
+
+ // Is second last param 'format string'?
+ var format *types.Var
+ if nparams >= 2 {
+ if p := params.At(nparams - 2); p.Type() == types.Typ[types.String] {
+ format = p
+ }
+ }
+
+ return &printfWrapper{
+ obj: fn,
+ fdecl: fdecl,
+ format: format,
+ args: args,
+ }
+}
+
+// findPrintfLike scans the entire package to find printf-like functions.
+func findPrintfLike(pass *analysis.Pass, res *Result) (interface{}, error) {
+ // Gather potential wrappers and call graph between them.
+ byObj := make(map[*types.Func]*printfWrapper)
+ var wrappers []*printfWrapper
+ for _, file := range pass.Files {
+ for _, decl := range file.Decls {
+ w := maybePrintfWrapper(pass.TypesInfo, decl)
+ if w == nil {
+ continue
+ }
+ byObj[w.obj] = w
+ wrappers = append(wrappers, w)
+ }
+ }
+
+ // Walk the graph to figure out which are really printf wrappers.
+ for _, w := range wrappers {
+ // Scan function for calls that could be to other printf-like functions.
+ ast.Inspect(w.fdecl.Body, func(n ast.Node) bool {
+ if w.failed {
+ return false
+ }
+
+ // TODO: Relax these checks; issue 26555.
+ if assign, ok := n.(*ast.AssignStmt); ok {
+ for _, lhs := range assign.Lhs {
+ if match(pass.TypesInfo, lhs, w.format) ||
+ match(pass.TypesInfo, lhs, w.args) {
+ // Modifies the format
+ // string or args in
+ // some way, so not a
+ // simple wrapper.
+ w.failed = true
+ return false
+ }
+ }
+ }
+ if un, ok := n.(*ast.UnaryExpr); ok && un.Op == token.AND {
+ if match(pass.TypesInfo, un.X, w.format) ||
+ match(pass.TypesInfo, un.X, w.args) {
+ // Taking the address of the
+ // format string or args,
+ // so not a simple wrapper.
+ w.failed = true
+ return false
+ }
+ }
+
+ call, ok := n.(*ast.CallExpr)
+ if !ok || len(call.Args) == 0 || !match(pass.TypesInfo, call.Args[len(call.Args)-1], w.args) {
+ return true
+ }
+
+ fn, kind := printfNameAndKind(pass, call)
+ if kind != 0 {
+ checkPrintfFwd(pass, w, call, kind, res)
+ return true
+ }
+
+ // If the call is to another function in this package,
+ // maybe we will find out it is printf-like later.
+ // Remember this call for later checking.
+ if fn != nil && fn.Pkg() == pass.Pkg && byObj[fn] != nil {
+ callee := byObj[fn]
+ callee.callers = append(callee.callers, printfCaller{w, call})
+ }
+
+ return true
+ })
+ }
+ return nil, nil
+}
+
+func match(info *types.Info, arg ast.Expr, param *types.Var) bool {
+ id, ok := arg.(*ast.Ident)
+ return ok && info.ObjectOf(id) == param
+}
+
+// checkPrintfFwd checks that a printf-forwarding wrapper is forwarding correctly.
+// It diagnoses writing fmt.Printf(format, args) instead of fmt.Printf(format, args...).
+func checkPrintfFwd(pass *analysis.Pass, w *printfWrapper, call *ast.CallExpr, kind Kind, res *Result) {
+ matched := kind == KindPrint ||
+ kind != KindNone && len(call.Args) >= 2 && match(pass.TypesInfo, call.Args[len(call.Args)-2], w.format)
+ if !matched {
+ return
+ }
+
+ if !call.Ellipsis.IsValid() {
+ typ, ok := pass.TypesInfo.Types[call.Fun].Type.(*types.Signature)
+ if !ok {
+ return
+ }
+ if len(call.Args) > typ.Params().Len() {
+ // If we're passing more arguments than what the
+ // print/printf function can take, adding an ellipsis
+ // would break the program. For example:
+ //
+ // func foo(arg1 string, arg2 ...interface{} {
+ // fmt.Printf("%s %v", arg1, arg2)
+ // }
+ return
+ }
+ desc := "printf"
+ if kind == KindPrint {
+ desc = "print"
+ }
+ pass.ReportRangef(call, "missing ... in args forwarded to %s-like function", desc)
+ return
+ }
+ fn := w.obj
+ var fact isWrapper
+ if !pass.ImportObjectFact(fn, &fact) {
+ fact.Kind = kind
+ pass.ExportObjectFact(fn, &fact)
+ res.funcs[fn] = kind
+ for _, caller := range w.callers {
+ checkPrintfFwd(pass, caller.w, caller.call, kind, res)
+ }
+ }
+}
+
+// isPrint records the print functions.
+// If a key ends in 'f' then it is assumed to be a formatted print.
+//
+// Keys are either values returned by (*types.Func).FullName,
+// or case-insensitive identifiers such as "errorf".
+//
+// The -funcs flag adds to this set.
+//
+// The set below includes facts for many important standard library
+// functions, even though the analysis is capable of deducing that, for
+// example, fmt.Printf forwards to fmt.Fprintf. We avoid relying on the
+// driver applying analyzers to standard packages because "go vet" does
+// not do so with gccgo, and nor do some other build systems.
+// TODO(adonovan): eliminate the redundant facts once this restriction
+// is lifted.
+//
+var isPrint = stringSet{
+ "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,
+
+ "runtime/trace.Logf": true,
+
+ "log.Print": true,
+ "log.Printf": true,
+ "log.Println": true,
+ "log.Fatal": true,
+ "log.Fatalf": true,
+ "log.Fatalln": true,
+ "log.Panic": true,
+ "log.Panicf": true,
+ "log.Panicln": 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).Print": true,
+ "(*log.Logger).Printf": true,
+ "(*log.Logger).Println": true,
+
+ "(*testing.common).Error": true,
+ "(*testing.common).Errorf": true,
+ "(*testing.common).Fatal": true,
+ "(*testing.common).Fatalf": true,
+ "(*testing.common).Log": true,
+ "(*testing.common).Logf": true,
+ "(*testing.common).Skip": true,
+ "(*testing.common).Skipf": true,
+ // *testing.T and B are detected by induction, but testing.TB is
+ // an interface and the inference can't follow dynamic calls.
+ "(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(pass *analysis.Pass, call *ast.CallExpr) (format string, idx int) {
+ typ := pass.TypesInfo.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(pass, 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(pass, call, idx); ok {
+ return s, idx
+ }
+ if pass.TypesInfo.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(pass *analysis.Pass, call *ast.CallExpr, idx int) (string, bool) {
+ if idx >= len(call.Args) {
+ return "", false
+ }
+ arg := call.Args[idx]
+ lit := pass.TypesInfo.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 checkCall(pass *analysis.Pass) {
+ inspect := pass.ResultOf[inspect.Analyzer].(*inspector.Inspector)
+ nodeFilter := []ast.Node{
+ (*ast.CallExpr)(nil),
+ }
+ inspect.Preorder(nodeFilter, func(n ast.Node) {
+ call := n.(*ast.CallExpr)
+ fn, kind := printfNameAndKind(pass, call)
+ switch kind {
+ case KindPrintf, KindErrorf:
+ checkPrintf(pass, kind, call, fn)
+ case KindPrint:
+ checkPrint(pass, call, fn)
+ }
+ })
+}
+
+func printfNameAndKind(pass *analysis.Pass, call *ast.CallExpr) (fn *types.Func, kind Kind) {
+ fn, _ = typeutil.Callee(pass.TypesInfo, call).(*types.Func)
+ if fn == nil {
+ return nil, 0
+ }
+
+ _, ok := isPrint[fn.FullName()]
+ if !ok {
+ // Next look up just "printf", for use with -printf.funcs.
+ _, ok = isPrint[strings.ToLower(fn.Name())]
+ }
+ if ok {
+ if fn.Name() == "Errorf" {
+ kind = KindErrorf
+ } else if strings.HasSuffix(fn.Name(), "f") {
+ kind = KindPrintf
+ } else {
+ kind = KindPrint
+ }
+ return fn, kind
+ }
+
+ var fact isWrapper
+ if pass.ImportObjectFact(fn, &fact) {
+ return fn, fact.Kind
+ }
+
+ return fn, KindNone
+}
+
+// isFormatter reports whether t could satisfy fmt.Formatter.
+// The only interface method to look for is "Format(State, rune)".
+func isFormatter(typ types.Type) bool {
+ // If the type is an interface, the value it holds might satisfy fmt.Formatter.
+ if _, ok := typ.Underlying().(*types.Interface); ok {
+ return true
+ }
+ obj, _, _ := types.LookupFieldOrMethod(typ, false, nil, "Format")
+ fn, ok := obj.(*types.Func)
+ if !ok {
+ return false
+ }
+ sig := fn.Type().(*types.Signature)
+ return sig.Params().Len() == 2 &&
+ sig.Results().Len() == 0 &&
+ isNamed(sig.Params().At(0).Type(), "fmt", "State") &&
+ types.Identical(sig.Params().At(1).Type(), types.Typ[types.Rune])
+}
+
+func isNamed(T types.Type, pkgpath, name string) bool {
+ named, ok := T.(*types.Named)
+ return ok && named.Obj().Pkg().Path() == pkgpath && named.Obj().Name() == name
+}
+
+// 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.
+ pass *analysis.Pass
+ 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 checkPrintf(pass *analysis.Pass, kind Kind, call *ast.CallExpr, fn *types.Func) {
+ format, idx := formatString(pass, call)
+ if idx < 0 {
+ if false {
+ pass.Reportf(call.Lparen, "can't check non-constant format in call to %s", fn.Name())
+ }
+ return
+ }
+
+ firstArg := idx + 1 // Arguments are immediately after format string.
+ if !strings.Contains(format, "%") {
+ if len(call.Args) > firstArg {
+ pass.Reportf(call.Lparen, "%s call has arguments but no formatting directives", fn.Name())
+ }
+ return
+ }
+ // Hard part: check formats against args.
+ argNum := firstArg
+ maxArgNum := firstArg
+ anyIndex := false
+ anyW := false
+ for i, w := 0, 0; i < len(format); i += w {
+ w = 1
+ if format[i] != '%' {
+ continue
+ }
+ state := parsePrintfVerb(pass, call, fn.Name(), format[i:], firstArg, argNum)
+ if state == nil {
+ return
+ }
+ w = len(state.format)
+ if !okPrintfArg(pass, call, state) { // One error per format is enough.
+ return
+ }
+ if state.hasIndex {
+ anyIndex = true
+ }
+ if state.verb == 'w' {
+ if kind != KindErrorf {
+ pass.Reportf(call.Pos(), "%s call has error-wrapping directive %%w", state.name)
+ return
+ }
+ if anyW {
+ pass.Reportf(call.Pos(), "%s call has more than one error-wrapping directive %%w", state.name)
+ return
+ }
+ anyW = 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
+ pass.ReportRangef(call, "%s call needs %v but has %v", fn.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.pass.ReportRangef(s.call, "%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.pass.ReportRangef(s.call, "%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 parsePrintfVerb(pass *analysis.Pass, 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,
+ pass: pass,
+ 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) {
+ pass.ReportRangef(call.Fun, "%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
+ argError
+ 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', sharpNumFlag, argInt | argFloat | argComplex | argPointer},
+ {'c', "-", argRune | argInt},
+ {'d', numFlag, argInt | argPointer},
+ {'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 | argPointer},
+ {'O', sharpNumFlag, argInt | argPointer},
+ {'p', "-#", argPointer},
+ {'q', " -+.0#", argRune | argInt | argString},
+ {'s', " -+.0", argString},
+ {'t', "-", argBool},
+ {'T', "-", anyType},
+ {'U', "-#", argRune | argInt},
+ {'v', allFlags, anyType},
+ {'w', allFlags, argError},
+ {'x', sharpNumFlag, argRune | argInt | argString | argPointer | argFloat | argComplex},
+ {'X', sharpNumFlag, argRune | argInt | argString | argPointer | argFloat | argComplex},
+}
+
+// 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 okPrintfArg(pass *analysis.Pass, 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
+ }
+ }
+
+ // Could current arg implement fmt.Formatter?
+ formatter := false
+ if state.argNum < len(call.Args) {
+ if tv, ok := pass.TypesInfo.Types[call.Args[state.argNum]]; ok {
+ formatter = isFormatter(tv.Type)
+ }
+ }
+
+ if !formatter {
+ if !found {
+ pass.ReportRangef(call, "%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)) {
+ pass.ReportRangef(call, "%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 !argCanBeChecked(pass, call, i, state) {
+ return
+ }
+ arg := call.Args[argNum]
+ if !matchArgType(pass, argInt, nil, arg) {
+ pass.ReportRangef(call, "%s format %s uses non-int %s as argument of *", state.name, state.format, analysisutil.Format(pass.Fset, arg))
+ return false
+ }
+ }
+
+ if state.verb == '%' || formatter {
+ return true
+ }
+ argNum := state.argNums[len(state.argNums)-1]
+ if !argCanBeChecked(pass, call, len(state.argNums)-1, state) {
+ return false
+ }
+ arg := call.Args[argNum]
+ if isFunctionValue(pass, arg) && state.verb != 'p' && state.verb != 'T' {
+ pass.ReportRangef(call, "%s format %s arg %s is a func value, not called", state.name, state.format, analysisutil.Format(pass.Fset, arg))
+ return false
+ }
+ if !matchArgType(pass, v.typ, nil, arg) {
+ typeString := ""
+ if typ := pass.TypesInfo.Types[arg].Type; typ != nil {
+ typeString = typ.String()
+ }
+ pass.ReportRangef(call, "%s format %s has arg %s of wrong type %s", state.name, state.format, analysisutil.Format(pass.Fset, arg), typeString)
+ return false
+ }
+ if v.typ&argString != 0 && v.verb != 'T' && !bytes.Contains(state.flags, []byte{'#'}) {
+ if methodName, ok := recursiveStringer(pass, arg); ok {
+ pass.ReportRangef(call, "%s format %s with arg %s causes recursive %s method call", state.name, state.format, analysisutil.Format(pass.Fset, arg), methodName)
+ return false
+ }
+ }
+ return true
+}
+
+// recursiveStringer reports whether the argument e is a potential
+// recursive call to stringer or is an error, such as t and &t in these examples:
+//
+// func (t *T) String() string { printf("%s", t) }
+// func (t T) Error() string { printf("%s", t) }
+// func (t T) String() string { printf("%s", &t) }
+func recursiveStringer(pass *analysis.Pass, e ast.Expr) (string, bool) {
+ typ := pass.TypesInfo.Types[e].Type
+
+ // It's unlikely to be a recursive stringer if it has a Format method.
+ if isFormatter(typ) {
+ return "", false
+ }
+
+ // Does e allow e.String() or e.Error()?
+ strObj, _, _ := types.LookupFieldOrMethod(typ, false, pass.Pkg, "String")
+ strMethod, strOk := strObj.(*types.Func)
+ errObj, _, _ := types.LookupFieldOrMethod(typ, false, pass.Pkg, "Error")
+ errMethod, errOk := errObj.(*types.Func)
+ if !strOk && !errOk {
+ return "", false
+ }
+
+ // Is the expression e within the body of that String or Error method?
+ var method *types.Func
+ if strOk && strMethod.Pkg() == pass.Pkg && strMethod.Scope().Contains(e.Pos()) {
+ method = strMethod
+ } else if errOk && errMethod.Pkg() == pass.Pkg && errMethod.Scope().Contains(e.Pos()) {
+ method = errMethod
+ } else {
+ return "", false
+ }
+
+ sig := method.Type().(*types.Signature)
+ if !isStringer(sig) {
+ return "", false
+ }
+
+ // Is it the receiver r, or &r?
+ if u, ok := e.(*ast.UnaryExpr); ok && u.Op == token.AND {
+ e = u.X // strip off & from &r
+ }
+ if id, ok := e.(*ast.Ident); ok {
+ if pass.TypesInfo.Uses[id] == sig.Recv() {
+ return method.Name(), true
+ }
+ }
+ return "", false
+}
+
+// isStringer reports whether the method signature matches the String() definition in fmt.Stringer.
+func isStringer(sig *types.Signature) bool {
+ return sig.Params().Len() == 0 &&
+ sig.Results().Len() == 1 &&
+ sig.Results().At(0).Type() == types.Typ[types.String]
+}
+
+// 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 isFunctionValue(pass *analysis.Pass, e ast.Expr) bool {
+ if typ := pass.TypesInfo.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 argCanBeChecked(pass *analysis.Pass, 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.
+ pass.ReportRangef(call, "%s format %s reads arg #%d, but call has %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 = `[bcdefgopqstvxEFGTUX]`
+)
+
+// checkPrint checks a call to an unformatted print routine such as Println.
+func checkPrint(pass *analysis.Pass, call *ast.CallExpr, fn *types.Func) {
+ firstArg := 0
+ typ := pass.TypesInfo.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") {
+ pass.ReportRangef(call, "%s does not take io.Writer but has first arg %s", fn.Name(), analysisutil.Format(pass.Fset, 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 {
+ pass.ReportRangef(call, "%s call has possible formatting directive %s", fn.Name(), m[0])
+ }
+ }
+ }
+ if strings.HasSuffix(fn.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") {
+ pass.ReportRangef(call, "%s arg list ends with redundant newline", fn.Name())
+ }
+ }
+ }
+ for _, arg := range args {
+ if isFunctionValue(pass, arg) {
+ pass.ReportRangef(call, "%s arg %s is a func value, not called", fn.Name(), analysisutil.Format(pass.Fset, arg))
+ }
+ if methodName, ok := recursiveStringer(pass, arg); ok {
+ pass.ReportRangef(call, "%s arg %s causes recursive call to %s method", fn.Name(), analysisutil.Format(pass.Fset, arg), methodName)
+ }
+ }
+}
+
+// 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)
+}
+
+// stringSet is a set-of-nonempty-strings-valued flag.
+// Note: elements without a '.' get lower-cased.
+type stringSet map[string]bool
+
+func (ss stringSet) String() string {
+ var list []string
+ for name := range ss {
+ list = append(list, name)
+ }
+ sort.Strings(list)
+ return strings.Join(list, ",")
+}
+
+func (ss stringSet) Set(flag string) error {
+ for _, name := range strings.Split(flag, ",") {
+ if len(name) == 0 {
+ return fmt.Errorf("empty string")
+ }
+ if !strings.Contains(name, ".") {
+ name = strings.ToLower(name)
+ }
+ ss[name] = true
+ }
+ return nil
+}
projects / dotfiles / .git / blobdiff