mirror of
https://github.com/autc04/Retro68.git
synced 2024-09-08 20:55:01 +00:00
781 lines
22 KiB
Go
781 lines
22 KiB
Go
// 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.stringers == nil {
|
|
f.stringers = make(map[*ast.Object]bool)
|
|
}
|
|
if l := d.Recv.List; len(l) == 1 {
|
|
if n := l[0].Names; len(n) == 1 {
|
|
f.stringers[n[0].Obj] = true
|
|
}
|
|
}
|
|
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.
|
|
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
|
|
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 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
|
|
}
|
|
// 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.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 {
|
|
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.stringers) == 0 {
|
|
return 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
|
|
}
|
|
}
|
|
|
|
// It's unlikely to be a recursive stringer if it has a Format method.
|
|
if typ := f.pkg.types[e].Type; typ != nil {
|
|
// Not a perfect match; see issue 6259.
|
|
if f.hasMethod(typ, "Format") {
|
|
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.
|
|
return f.stringers[obj]
|
|
}
|
|
|
|
// 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)
|
|
}
|