src/cmd/govet/govet.go - go - 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.

 // Govet is a simple checker for static errors in Go source code.
 // See doc.go for more information.
 package main

 import (
 	"bytes"
 	"flag"
 	"fmt"
 	"io"
 	"go/ast"
 	"go/parser"
 	"go/token"
 	"os"
 	"path"
 	"strconv"
 	"strings"
 )

 var verbose = flag.Bool("v", false, "verbose")
 var printfuncs = flag.String("printfuncs", "", "comma-separated list of print function names to check")
 var exitCode = 0

 // setExit sets the value for os.Exit when it is called, later.  It
 // remembers the highest value.
 func setExit(err int) {
 	if err > exitCode {
 		exitCode = err
 	}
 }

 // Usage is a replacement usage function for the flags package.
 func Usage() {
 	fmt.Fprintf(os.Stderr, "Usage of %s:\n", os.Args[0])
 	flag.PrintDefaults()
 	os.Exit(2)
 }

 // File is a wrapper for the state of a file used in the parser.
 // The parse tree walkers are all methods of this type.
 type File struct {
 	file *token.File
 }

 func main() {
 	flag.Usage = Usage
 	flag.Parse()

 	if *printfuncs != "" {
 		for _, name := range strings.Split(*printfuncs, ",", -1) {
 			if len(name) == 0 {
 				flag.Usage()
 			}
 			skip := 0
 			if colon := strings.LastIndex(name, ":"); colon > 0 {
 				var err os.Error
 				skip, err = strconv.Atoi(name[colon+1:])
 				if err != nil {
 					error(`illegal format for "Func:N" argument %q; %s`, name, err)
 				}
 				name = name[:colon]
 			}
 			if name[len(name)-1] == 'f' {
 				printfList[name] = skip
 			} else {
 				printList[name] = skip
 			}
 		}
 	}

 	if flag.NArg() == 0 {
 		doFile("stdin", os.Stdin)
 	} else {
 		for _, name := range flag.Args() {
 			// Is it a directory?
 			if fi, err := os.Stat(name); err == nil && fi.IsDirectory() {
 				walkDir(name)
 			} else {
 				doFile(name, nil)
 			}
 		}
 	}
 	os.Exit(exitCode)
 }

 // doFile analyzes one file.  If the reader is nil, the source code is read from the
 // named file.
 func doFile(name string, reader io.Reader) {
 	fs := token.NewFileSet()
 	parsedFile, err := parser.ParseFile(fs, name, reader, 0)
 	if err != nil {
 		error("%s: %s", name, err)
 		return
 	}
 	file := &File{fs.File(parsedFile.Pos())}
 	file.checkFile(name, parsedFile)
 }

 // Visitor for path.Walk - trivial.  Just calls doFile on each file.
 // TODO: if govet becomes richer, might want to process
 // a directory (package) at a time.
 type V struct{}

 func (v V) VisitDir(path string, f *os.FileInfo) bool {
 	return true
 }

 func (v V) VisitFile(path string, f *os.FileInfo) {
 	if strings.HasSuffix(path, ".go") {
 		doFile(path, nil)
 	}
 }

 // walkDir recursively walks the tree looking for .go files.
 func walkDir(root string) {
 	errors := make(chan os.Error)
 	done := make(chan bool)
 	go func() {
 		for e := range errors {
 			error("walk error: %s", e)
 		}
 		done <- true
 	}()
 	path.Walk(root, V{}, errors)
 	close(errors)
 	<-done
 }

 // error formats the error to standard error, adding program
 // identification and a newline
 func error(format string, args ...interface{}) {
 	fmt.Fprintf(os.Stderr, "govet: "+format+"\n", args...)
 	setExit(2)
 }

 // Println is fmt.Println guarded by -v.
 func Println(args ...interface{}) {
 	if !*verbose {
 		return
 	}
 	fmt.Println(args...)
 }

 // Printf is fmt.Printf guarded by -v.
 func Printf(format string, args ...interface{}) {
 	if !*verbose {
 		return
 	}
 	fmt.Printf(format+"\n", args...)
 }

 // Bad reports an error and sets the exit code..
 func (f *File) Bad(pos token.Pos, args ...interface{}) {
 	f.Warn(pos, args...)
 	setExit(1)
 }

 // Badf reports a formatted error and sets the exit code.
 func (f *File) Badf(pos token.Pos, format string, args ...interface{}) {
 	f.Warnf(pos, format, args...)
 	setExit(1)
 }

 // Warn reports an error but does not set the exit code.
 func (f *File) Warn(pos token.Pos, args ...interface{}) {
 	loc := f.file.Position(pos).String() + ": "
 	fmt.Fprint(os.Stderr, loc+fmt.Sprintln(args...))
 }

 // Warnf reports a formatted error but does not set the exit code.
 func (f *File) Warnf(pos token.Pos, format string, args ...interface{}) {
 	loc := f.file.Position(pos).String() + ": "
 	fmt.Fprintf(os.Stderr, loc+format+"\n", args...)
 }

 // checkFile checks all the top-level declarations in a file.
 func (f *File) checkFile(name string, file *ast.File) {
 	Println("Checking file", name)
 	ast.Walk(f, file)
 }

 // Visit implements the ast.Visitor interface.
 func (f *File) Visit(node ast.Node) ast.Visitor {
 	// TODO: could return nil for nodes that cannot contain a CallExpr -
 	// will shortcut traversal.  Worthwhile?
 	switch n := node.(type) {
 	case *ast.CallExpr:
 		f.checkCallExpr(n)
 	}
 	return f
 }


 // checkCallExpr checks a call expression.
 func (f *File) checkCallExpr(call *ast.CallExpr) {
 	switch x := call.Fun.(type) {
 	case *ast.Ident:
 		f.checkCall(call, x.Name)
 	case *ast.SelectorExpr:
 		f.checkCall(call, x.Sel.Name)
 	}
 }

 // printfList records the formatted-print functions. The value is the location
 // of the format parameter.
 var printfList = map[string]int{
 	"Errorf":  0,
 	"Fatalf":  0,
 	"Fprintf": 1,
 	"Panicf":  0,
 	"Printf":  0,
 	"Sprintf": 0,
 }

 // printList records the unformatted-print functions. The value is the location
 // of the first parameter to be printed.
 var printList = map[string]int{
 	"Error":  0,
 	"Fatal":  0,
 	"Fprint": 1, "Fprintln": 1,
 	"Panic": 0, "Panicln": 0,
 	"Print": 0, "Println": 0,
 	"Sprint": 0, "Sprintln": 0,
 }

 // checkCall triggers the print-specific checks if the call invokes a print function.
 func (f *File) checkCall(call *ast.CallExpr, name string) {
 	if skip, ok := printfList[name]; ok {
 		f.checkPrintf(call, name, skip)
 		return
 	}
 	if skip, ok := printList[name]; ok {
 		f.checkPrint(call, name, skip)
 		return
 	}
 }

 // checkPrintf checks a call to a formatted print routine such as Printf.
 // The skip argument records how many arguments to ignore; that is,
 // call.Args[skip] is (well, should be) the format argument.
 func (f *File) checkPrintf(call *ast.CallExpr, name string, skip int) {
 	if len(call.Args) <= skip {
 		return
 	}
 	// Common case: literal is first argument.
 	arg := call.Args[skip]
 	lit, ok := arg.(*ast.BasicLit)
 	if !ok {
 		// Too hard to check.
 		if *verbose {
 			f.Warn(call.Pos(), "can't check args for call to", name)
 		}
 		return
 	}
 	if lit.Kind == token.STRING {
 		if bytes.IndexByte(lit.Value, '%') < 0 {
 			if len(call.Args) > skip+1 {
 				f.Badf(call.Pos(), "no formatting directive in %s call", name)
 			}
 			return
 		}
 	}
 	// Hard part: check formats against args.
 	// Trivial but useful test: count.
 	numPercent := 0
 	for i := 0; i < len(lit.Value); i++ {
 		if lit.Value[i] == '%' {
 			if i+1 < len(lit.Value) && lit.Value[i+1] == '%' {
 				// %% doesn't count.
 				i++
 			} else {
 				numPercent++
 			}
 		}
 	}
 	expect := len(call.Args) - (skip + 1)
 	if numPercent != expect {
 		f.Badf(call.Pos(), "wrong number of formatting directives in %s call: %d percent(s) for %d args", name, numPercent, expect)
 	}
 }

 var terminalNewline = []byte(`\n"`) // \n at end of interpreted string

 // checkPrint checks a call to an unformatted print routine such as Println.
 // The skip argument records how many arguments to ignore; that is,
 // call.Args[skip] is the first argument to be printed.
 func (f *File) checkPrint(call *ast.CallExpr, name string, skip int) {
 	isLn := strings.HasSuffix(name, "ln")
 	args := call.Args
 	if len(args) <= skip {
 		if *verbose && !isLn {
 			f.Badf(call.Pos(), "no args in %s call", name)
 		}
 		return
 	}
 	arg := args[skip]
 	if lit, ok := arg.(*ast.BasicLit); ok && lit.Kind == token.STRING {
 		if bytes.IndexByte(lit.Value, '%') >= 0 {
 			f.Badf(call.Pos(), "possible formatting directive in %s call", name)
 		}
 	}
 	if isLn {
 		// The last item, if a string, should not have a newline.
 		arg = args[len(call.Args)-1]
 		if lit, ok := arg.(*ast.BasicLit); ok && lit.Kind == token.STRING {
 			if bytes.HasSuffix(lit.Value, terminalNewline) {
 				f.Badf(call.Pos(), "%s call ends with newline", name)
 			}
 		}
 	}
 }

 // This function never executes, but it serves as a simple test for the program.
 // Test with govet -printfuncs="Bad:1,Badf:1,Warn:1,Warnf:1" govet.go
 func BadFunctionUsedInTests() {
 	fmt.Println()                      // niladic call
 	fmt.Println("%s", "hi")            // % in call to Println
 	fmt.Printf("%s", "hi", 3)          // wrong # percents
 	fmt.Printf("%s%%%d", "hi", 3)      // right # percents
 	Printf("now is the time", "buddy") // no %s
 	f := new(File)
 	f.Warn(0, "%s", "hello", 3)  // % in call to added function
 	f.Warnf(0, "%s", "hello", 3) // wrong # %s in call to added function
 }
	// 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.

	// Govet is a simple checker for static errors in Go source code.
	// See doc.go for more information.
	package main

	import (
	"bytes"
	"flag"
	"fmt"
	"io"
	"go/ast"
	"go/parser"
	"go/token"
	"os"
	"path"
	"strconv"
	"strings"
	)

	var verbose = flag.Bool("v", false, "verbose")
	var printfuncs = flag.String("printfuncs", "", "comma-separated list of print function names to check")
	var exitCode = 0

	// setExit sets the value for os.Exit when it is called, later. It
	// remembers the highest value.
	func setExit(err int) {
	if err > exitCode {
	exitCode = err
	}
	}

	// Usage is a replacement usage function for the flags package.
	func Usage() {
	fmt.Fprintf(os.Stderr, "Usage of %s:\n", os.Args[0])
	flag.PrintDefaults()
	os.Exit(2)
	}

	// File is a wrapper for the state of a file used in the parser.
	// The parse tree walkers are all methods of this type.
	type File struct {
	file *token.File
	}

	func main() {
	flag.Usage = Usage
	flag.Parse()

	if *printfuncs != "" {
	for _, name := range strings.Split(*printfuncs, ",", -1) {
	if len(name) == 0 {
	flag.Usage()
	}
	skip := 0
	if colon := strings.LastIndex(name, ":"); colon > 0 {
	var err os.Error
	skip, err = strconv.Atoi(name[colon+1:])
	if err != nil {
	error(`illegal format for "Func:N" argument %q; %s`, name, err)
	}
	name = name[:colon]
	}
	if name[len(name)-1] == 'f' {
	printfList[name] = skip
	} else {
	printList[name] = skip
	}
	}
	}

	if flag.NArg() == 0 {
	doFile("stdin", os.Stdin)
	} else {
	for _, name := range flag.Args() {
	// Is it a directory?
	if fi, err := os.Stat(name); err == nil && fi.IsDirectory() {
	walkDir(name)
	} else {
	doFile(name, nil)
	}
	}
	}
	os.Exit(exitCode)
	}

	// doFile analyzes one file. If the reader is nil, the source code is read from the
	// named file.
	func doFile(name string, reader io.Reader) {
	fs := token.NewFileSet()
	parsedFile, err := parser.ParseFile(fs, name, reader, 0)
	if err != nil {
	error("%s: %s", name, err)
	return
	}
	file := &File{fs.File(parsedFile.Pos())}
	file.checkFile(name, parsedFile)
	}

	// Visitor for path.Walk - trivial. Just calls doFile on each file.
	// TODO: if govet becomes richer, might want to process
	// a directory (package) at a time.
	type V struct{}

	func (v V) VisitDir(path string, f *os.FileInfo) bool {
	return true
	}

	func (v V) VisitFile(path string, f *os.FileInfo) {
	if strings.HasSuffix(path, ".go") {
	doFile(path, nil)
	}
	}

	// walkDir recursively walks the tree looking for .go files.
	func walkDir(root string) {
	errors := make(chan os.Error)
	done := make(chan bool)
	go func() {
	for e := range errors {
	error("walk error: %s", e)
	}
	done <- true
	}()
	path.Walk(root, V{}, errors)
	close(errors)
	<-done
	}

	// error formats the error to standard error, adding program
	// identification and a newline
	func error(format string, args ...interface{}) {
	fmt.Fprintf(os.Stderr, "govet: "+format+"\n", args...)
	setExit(2)
	}

	// Println is fmt.Println guarded by -v.
	func Println(args ...interface{}) {
	if !*verbose {
	return
	}
	fmt.Println(args...)
	}

	// Printf is fmt.Printf guarded by -v.
	func Printf(format string, args ...interface{}) {
	if !*verbose {
	return
	}
	fmt.Printf(format+"\n", args...)
	}

	// Bad reports an error and sets the exit code..
	func (f *File) Bad(pos token.Pos, args ...interface{}) {
	f.Warn(pos, args...)
	setExit(1)
	}

	// Badf reports a formatted error and sets the exit code.
	func (f *File) Badf(pos token.Pos, format string, args ...interface{}) {
	f.Warnf(pos, format, args...)
	setExit(1)
	}

	// Warn reports an error but does not set the exit code.
	func (f *File) Warn(pos token.Pos, args ...interface{}) {
	loc := f.file.Position(pos).String() + ": "
	fmt.Fprint(os.Stderr, loc+fmt.Sprintln(args...))
	}

	// Warnf reports a formatted error but does not set the exit code.
	func (f *File) Warnf(pos token.Pos, format string, args ...interface{}) {
	loc := f.file.Position(pos).String() + ": "
	fmt.Fprintf(os.Stderr, loc+format+"\n", args...)
	}

	// checkFile checks all the top-level declarations in a file.
	func (f File) checkFile(name string, file ast.File) {
	Println("Checking file", name)
	ast.Walk(f, file)
	}

	// Visit implements the ast.Visitor interface.
	func (f *File) Visit(node ast.Node) ast.Visitor {
	// TODO: could return nil for nodes that cannot contain a CallExpr -
	// will shortcut traversal. Worthwhile?
	switch n := node.(type) {
	case *ast.CallExpr:
	f.checkCallExpr(n)
	}
	return f
	}


	// checkCallExpr checks a call expression.
	func (f File) checkCallExpr(call ast.CallExpr) {
	switch x := call.Fun.(type) {
	case *ast.Ident:
	f.checkCall(call, x.Name)
	case *ast.SelectorExpr:
	f.checkCall(call, x.Sel.Name)
	}
	}

	// printfList records the formatted-print functions. The value is the location
	// of the format parameter.
	var printfList = map[string]int{
	"Errorf": 0,
	"Fatalf": 0,
	"Fprintf": 1,
	"Panicf": 0,
	"Printf": 0,
	"Sprintf": 0,
	}

	// printList records the unformatted-print functions. The value is the location
	// of the first parameter to be printed.
	var printList = map[string]int{
	"Error": 0,
	"Fatal": 0,
	"Fprint": 1, "Fprintln": 1,
	"Panic": 0, "Panicln": 0,
	"Print": 0, "Println": 0,
	"Sprint": 0, "Sprintln": 0,
	}

	// checkCall triggers the print-specific checks if the call invokes a print function.
	func (f File) checkCall(call ast.CallExpr, name string) {
	if skip, ok := printfList[name]; ok {
	f.checkPrintf(call, name, skip)
	return
	}
	if skip, ok := printList[name]; ok {
	f.checkPrint(call, name, skip)
	return
	}
	}

	// checkPrintf checks a call to a formatted print routine such as Printf.
	// The skip argument records how many arguments to ignore; that is,
	// call.Args[skip] is (well, should be) the format argument.
	func (f File) checkPrintf(call ast.CallExpr, name string, skip int) {
	if len(call.Args) <= skip {
	return
	}
	// Common case: literal is first argument.
	arg := call.Args[skip]
	lit, ok := arg.(*ast.BasicLit)
	if !ok {
	// Too hard to check.
	if *verbose {
	f.Warn(call.Pos(), "can't check args for call to", name)
	}
	return
	}
	if lit.Kind == token.STRING {
	if bytes.IndexByte(lit.Value, '%') < 0 {
	if len(call.Args) > skip+1 {
	f.Badf(call.Pos(), "no formatting directive in %s call", name)
	}
	return
	}
	}
	// Hard part: check formats against args.
	// Trivial but useful test: count.
	numPercent := 0
	for i := 0; i < len(lit.Value); i++ {
	if lit.Value[i] == '%' {
	if i+1 < len(lit.Value) && lit.Value[i+1] == '%' {
	// %% doesn't count.
	i++
	} else {
	numPercent++
	}
	}
	}
	expect := len(call.Args) - (skip + 1)
	if numPercent != expect {
	f.Badf(call.Pos(), "wrong number of formatting directives in %s call: %d percent(s) for %d args", name, numPercent, expect)
	}
	}

	var terminalNewline = []byte(`\n"`) // \n at end of interpreted string

	// checkPrint checks a call to an unformatted print routine such as Println.
	// The skip argument records how many arguments to ignore; that is,
	// call.Args[skip] is the first argument to be printed.
	func (f File) checkPrint(call ast.CallExpr, name string, skip int) {
	isLn := strings.HasSuffix(name, "ln")
	args := call.Args
	if len(args) <= skip {
	if *verbose && !isLn {
	f.Badf(call.Pos(), "no args in %s call", name)
	}
	return
	}
	arg := args[skip]
	if lit, ok := arg.(*ast.BasicLit); ok && lit.Kind == token.STRING {
	if bytes.IndexByte(lit.Value, '%') >= 0 {
	f.Badf(call.Pos(), "possible formatting directive in %s call", name)
	}
	}
	if isLn {
	// The last item, if a string, should not have a newline.
	arg = args[len(call.Args)-1]
	if lit, ok := arg.(*ast.BasicLit); ok && lit.Kind == token.STRING {
	if bytes.HasSuffix(lit.Value, terminalNewline) {
	f.Badf(call.Pos(), "%s call ends with newline", name)
	}
	}
	}
	}

	// This function never executes, but it serves as a simple test for the program.
	// Test with govet -printfuncs="Bad:1,Badf:1,Warn:1,Warnf:1" govet.go
	func BadFunctionUsedInTests() {
	fmt.Println() // niladic call
	fmt.Println("%s", "hi") // % in call to Println
	fmt.Printf("%s", "hi", 3) // wrong # percents
	fmt.Printf("%s%%%d", "hi", 3) // right # percents
	Printf("now is the time", "buddy") // no %s
	f := new(File)
	f.Warn(0, "%s", "hello", 3) // % in call to added function
	f.Warnf(0, "%s", "hello", 3) // wrong # %s in call to added function
	}