src/cmd/vet/print.go - go.git - Git at Google

 // 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"
 	"go/ast"
 	"go/constant"
 	"go/token"
 	"go/types"
 	"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]
 		}

 		name = strings.ToLower(name)
 		if name[len(name)-1] == 'f' {
 			isFormattedPrint[name] = true
 		} else {
 			isPrint[name] = true
 		}
 	}
 }

 // isFormattedPrint records the formatted-print functions. Names are
 // lower-cased so the lookup is case insensitive.
 var isFormattedPrint = map[string]bool{
 	"errorf":  true,
 	"fatalf":  true,
 	"fprintf": true,
 	"logf":    true,
 	"panicf":  true,
 	"printf":  true,
 	"sprintf": true,
 }

 // isPrint records the unformatted-print functions. Names are lower-cased
 // so the lookup is case insensitive.
 var isPrint = map[string]bool{
 	"error":    true,
 	"fatal":    true,
 	"fprint":   true,
 	"fprintln": true,
 	"log":      true,
 	"panic":    true,
 	"panicln":  true,
 	"print":    true,
 	"println":  true,
 	"sprint":   true,
 	"sprintln": 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) (string, 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 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
 	}
 	var Name string
 	switch x := call.Fun.(type) {
 	case *ast.Ident:
 		Name = x.Name
 	case *ast.SelectorExpr:
 		Name = x.Sel.Name
 	default:
 		return
 	}

 	name := strings.ToLower(Name)
 	if _, ok := isFormattedPrint[name]; ok {
 		f.checkPrintf(call, Name)
 		return
 	}
 	if _, ok := isPrint[name]; ok {
 		f.checkPrint(call, Name)
 		return
 	}
 }

 // 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(), "no formatting directive in %s call", 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] == '%' {
 			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(), "wrong number of args for format in %s call: %d needed but %d args", name, expect, numArgs)
 	}
 }

 // 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()
 	if s.nbytes == len(s.format) || s.nbytes == start || s.format[s.nbytes] != ']' {
 		end := strings.Index(s.format, "]")
 		if end < 0 {
 			end = len(s.format)
 		}
 		s.file.Badf(s.call.Pos(), "bad syntax for printf argument index: [%s]", s.format[start:end])
 		return false
 	}
 	arg32, err := strconv.ParseInt(s.format[start:s.nbytes], 10, 32)
 	if err != nil {
 		s.file.Badf(s.call.Pos(), "bad syntax for printf argument index: %s", err)
 		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(), "missing verb at end of format string in %s call", name)
 		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', numFlag, argFloat | argComplex},
 	{'E', numFlag, argFloat | argComplex},
 	{'f', numFlag, argFloat | argComplex},
 	{'F', numFlag, argFloat | argComplex},
 	{'g', numFlag, argFloat | argComplex},
 	{'G', numFlag, 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 !found && !formatter {
 		f.Badf(call.Pos(), "unrecognized printf verb %q", state.verb)
 		return false
 	}
 	for _, flag := range state.flags {
 		if !strings.ContainsRune(v.flags, rune(flag)) {
 			f.Badf(call.Pos(), "unrecognized printf flag for verb %q: %q", state.verb, 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, true, state) {
 			return
 		}
 		arg := call.Args[argNum]
 		if !f.matchArgType(argInt, nil, arg) {
 			f.Badf(call.Pos(), "arg %s for * in printf format not of type int", 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, false, state) {
 		return false
 	}
 	arg := call.Args[argNum]
 	if f.isFunctionValue(arg) && state.verb != 'p' && state.verb != 'T' {
 		f.Badf(call.Pos(), "arg %s in printf call is a function value, not a function call", 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(), "arg %s for printf verb %%%c of wrong type: %s", f.gofmt(arg), state.verb, typeString)
 		return false
 	}
 	if v.typ&argString != 0 && v.verb != 'T' && !bytes.Contains(state.flags, []byte{'#'}) && f.recursiveStringer(arg) {
 		f.Badf(call.Pos(), "arg %s for printf causes recursive call to String method", 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, isStar bool, state *formatState) bool {
 	argNum := state.argNums[formatArg]
 	if argNum < 0 {
 		// Shouldn't happen, so catch it with prejudice.
 		panic("negative arg num")
 	}
 	if argNum == 0 {
 		f.Badf(call.Pos(), `index value [0] for %s("%s"); indexes start at 1`, state.name, state.format)
 		return false
 	}
 	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(), `missing argument for %s("%s"): format reads arg %d, have only %d args`, state.name, state.format, arg, len(call.Args)-state.firstArg)
 	return false
 }

 // 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:]

 	// check for Println(os.Stderr, ...)
 	if firstArg == 0 {
 		if sel, ok := 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(), "first argument to %s is %s.%s", name, x.Name, sel.Sel.Name)
 				}
 			}
 		}
 	}
 	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, "%") {
 			f.Badf(call.Pos(), "possible formatting directive in %s call", name)
 		}
 	}
 	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 {
 			if strings.HasSuffix(lit.Value, `\n"`) {
 				f.Badf(call.Pos(), "%s call ends with newline", name)
 			}
 		}
 	}
 	for _, arg := range args {
 		if f.isFunctionValue(arg) {
 			f.Badf(call.Pos(), "arg %s in %s call is a function value, not a function call", f.gofmt(arg), name)
 		}
 		if f.recursiveStringer(arg) {
 			f.Badf(call.Pos(), "arg %s in %s call causes recursive call to String method", f.gofmt(arg), name)
 		}
 	}
 }
	// 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"
	"go/ast"
	"go/constant"
	"go/token"
	"go/types"
	"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]
	}

	name = strings.ToLower(name)
	if name[len(name)-1] == 'f' {
	isFormattedPrint[name] = true
	} else {
	isPrint[name] = true
	}
	}
	}

	// isFormattedPrint records the formatted-print functions. Names are
	// lower-cased so the lookup is case insensitive.
	var isFormattedPrint = map[string]bool{
	"errorf": true,
	"fatalf": true,
	"fprintf": true,
	"logf": true,
	"panicf": true,
	"printf": true,
	"sprintf": true,
	}

	// isPrint records the unformatted-print functions. Names are lower-cased
	// so the lookup is case insensitive.
	var isPrint = map[string]bool{
	"error": true,
	"fatal": true,
	"fprint": true,
	"fprintln": true,
	"log": true,
	"panic": true,
	"panicln": true,
	"print": true,
	"println": true,
	"sprint": true,
	"sprintln": 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) (string, 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 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
	}
	var Name string
	switch x := call.Fun.(type) {
	case *ast.Ident:
	Name = x.Name
	case *ast.SelectorExpr:
	Name = x.Sel.Name
	default:
	return
	}

	name := strings.ToLower(Name)
	if _, ok := isFormattedPrint[name]; ok {
	f.checkPrintf(call, Name)
	return
	}
	if _, ok := isPrint[name]; ok {
	f.checkPrint(call, Name)
	return
	}
	}

	// 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(), "no formatting directive in %s call", 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] == '%' {
	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(), "wrong number of args for format in %s call: %d needed but %d args", name, expect, numArgs)
	}
	}

	// 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()
	if s.nbytes == len(s.format) \|\| s.nbytes == start \|\| s.format[s.nbytes] != ']' {
	end := strings.Index(s.format, "]")
	if end < 0 {
	end = len(s.format)
	}
	s.file.Badf(s.call.Pos(), "bad syntax for printf argument index: [%s]", s.format[start:end])
	return false
	}
	arg32, err := strconv.ParseInt(s.format[start:s.nbytes], 10, 32)
	if err != nil {
	s.file.Badf(s.call.Pos(), "bad syntax for printf argument index: %s", err)
	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(), "missing verb at end of format string in %s call", name)
	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', numFlag, argFloat \| argComplex},
	{'E', numFlag, argFloat \| argComplex},
	{'f', numFlag, argFloat \| argComplex},
	{'F', numFlag, argFloat \| argComplex},
	{'g', numFlag, argFloat \| argComplex},
	{'G', numFlag, 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 !found && !formatter {
	f.Badf(call.Pos(), "unrecognized printf verb %q", state.verb)
	return false
	}
	for _, flag := range state.flags {
	if !strings.ContainsRune(v.flags, rune(flag)) {
	f.Badf(call.Pos(), "unrecognized printf flag for verb %q: %q", state.verb, 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, true, state) {
	return
	}
	arg := call.Args[argNum]
	if !f.matchArgType(argInt, nil, arg) {
	f.Badf(call.Pos(), "arg %s for * in printf format not of type int", 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, false, state) {
	return false
	}
	arg := call.Args[argNum]
	if f.isFunctionValue(arg) && state.verb != 'p' && state.verb != 'T' {
	f.Badf(call.Pos(), "arg %s in printf call is a function value, not a function call", 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(), "arg %s for printf verb %%%c of wrong type: %s", f.gofmt(arg), state.verb, typeString)
	return false
	}
	if v.typ&argString != 0 && v.verb != 'T' && !bytes.Contains(state.flags, []byte{'#'}) && f.recursiveStringer(arg) {
	f.Badf(call.Pos(), "arg %s for printf causes recursive call to String method", 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, isStar bool, state *formatState) bool {
	argNum := state.argNums[formatArg]
	if argNum < 0 {
	// Shouldn't happen, so catch it with prejudice.
	panic("negative arg num")
	}
	if argNum == 0 {
	f.Badf(call.Pos(), `index value [0] for %s("%s"); indexes start at 1`, state.name, state.format)
	return false
	}
	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(), `missing argument for %s("%s"): format reads arg %d, have only %d args`, state.name, state.format, arg, len(call.Args)-state.firstArg)
	return false
	}

	// 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:]

	// check for Println(os.Stderr, ...)
	if firstArg == 0 {
	if sel, ok := 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(), "first argument to %s is %s.%s", name, x.Name, sel.Sel.Name)
	}
	}
	}
	}
	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, "%") {
	f.Badf(call.Pos(), "possible formatting directive in %s call", name)
	}
	}
	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 {
	if strings.HasSuffix(lit.Value, `\n"`) {
	f.Badf(call.Pos(), "%s call ends with newline", name)
	}
	}
	}
	for _, arg := range args {
	if f.isFunctionValue(arg) {
	f.Badf(call.Pos(), "arg %s in %s call is a function value, not a function call", f.gofmt(arg), name)
	}
	if f.recursiveStringer(arg) {
	f.Badf(call.Pos(), "arg %s in %s call causes recursive call to String method", f.gofmt(arg), name)
	}
	}
	}