code review 4645069: reflect: support for struct tag use by multiple packages

src/cmd/govet/govet.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.
 
 // Govet is a simple checker for static errors in Go source code.
 // See doc.go for more information.
 package main
 
 import (
         "flag"
         "fmt"
         "io"
         "go/ast"
         "go/parser"
         "go/token"
         "os"
         "path/filepath"
+        "reflect"
         "strconv"
         "strings"
         "utf8"
 )
 
 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
@@ skipping 24 matching lines @@
         if *printfuncs != "" {
                 for _, name := range strings.Split(*printfuncs, ",") {
                         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)
+                                        errorf(`illegal format for "Func:N" argument %q; %s`, name, err)
                                 }
                                 name = name[:colon]
                         }
                         name = strings.ToLower(name)
                         if name[len(name)-1] == 'f' {
                                 printfList[name] = skip
                         } else {
                                 printList[name] = skip
                         }
                 }
@@ skipping 13 matching lines @@
         }
         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)
+                errorf("%s: %s", name, err)
                 return
         }
         file := &File{fs.File(parsedFile.Pos())}
         file.checkFile(name, parsedFile)
 }
 
 // Visitor for filepath.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)
+                        errorf("walk error: %s", e)
                 }
                 done <- true
         }()
         filepath.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{}) {
+func errorf(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...)
@@ skipping 32 matching lines @@
 }
 
 // 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)
+        case *ast.Field:
+                f.checkFieldTag(n)
         }
         return f
 }
 
+// checkField checks a struct field tag.
+func (f *File) checkFieldTag(field *ast.Field) {
+        if field.Tag == nil {
+                return
+        }
+
+        tag, err := strconv.Unquote(field.Tag.Value)
+        if err != nil {
+                f.Warnf(field.Pos(), "unable to read struct tag %s", field.Tag.Value)
+                return
+        }
+
+        // Check tag for validity by appending
+        // new key:value to end and checking that
+        // the tag parsing code can find it.
+        if reflect.StructTag(tag+` _gofix:"_magic"`).Get("_gofix") != "_magic" {
+                f.Warnf(field.Pos(), "struct field tag %s not compatible with reflect.StructTag.Get", field.Tag.Value)
+                return
+        }
+}
 
 // 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)
         }
 }
@@ skipping 159 matching lines @@
         fmt.Printf("%s%%%d", "hi", 3)      // right # percents
         fmt.Printf("%.*d", 3, 3)           // right # percents, with a *
         fmt.Printf("%.*d", 3, 3, 3)        // wrong # percents, with a *
         printf("now is the time", "buddy") // no %s
         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
 }
 
+type BadTypeUsedInTests struct {
+        X int "hello" // struct field not well-formed
+}
+
 // printf is used by the test.
 func printf(format string, args ...interface{}) {
         panic("don't call - testing only")
 }