code review 5416060: io: new FileInfo, FileMode types + update tree

src/cmd/gofix/main.go

 // Copyright 2011 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 main
 
 import (
         "bytes"
         "flag"
         "fmt"
@@ skipping 91 matching lines @@
 
 var printConfig = &printer.Config{
         printerMode,
         tabWidth,
 }
 
 func gofmtFile(f *ast.File) ([]byte, error) {
         var buf bytes.Buffer
 
         ast.SortImports(fset, f)
-        _, err := printConfig.Fprint(&buf, fset, f)
+        err := printConfig.Fprint(&buf, fset, f)
         if err != nil {
                 return nil, err
         }
         return buf.Bytes(), nil
 }
 
 func processFile(filename string, useStdin bool) error {
         var f *os.File
         var err error
         var fixlog bytes.Buffer
@@ skipping 73 matching lines @@
                 return nil
         }
 
         return ioutil.WriteFile(f.Name(), newSrc, 0)
 }
 
 var gofmtBuf bytes.Buffer
 
 func gofmt(n interface{}) string {
         gofmtBuf.Reset()
-        _, err := printConfig.Fprint(&gofmtBuf, fset, n)
+        err := printConfig.Fprint(&gofmtBuf, fset, n)
         if err != nil {
                 return "<" + err.Error() + ">"
         }
         return gofmtBuf.String()
 }
 
 func report(err error) {
         scanner.PrintError(os.Stderr, err)
         exitCode = 2
 }
 
 func walkDir(path string) {
         filepath.Walk(path, visitFile)
 }
 
 func visitFile(path string, f os.FileInfo, err error) error {
         if err == nil && isGoFile(f) {
                 err = processFile(path, false)
         }
         if err != nil {
                 report(err)
         }
         return nil
 }
 
 func isGoFile(f os.FileInfo) bool {
         // ignore non-Go files
         name := f.Name()
-        mode := f.Mode()
-        return !mode.IsDir() && !strings.HasPrefix(name, ".") && strings.HasSuffix(name, ".go")

[gri, 2011/11/28 21:06:24]

just f.IsDir() and get rid of mode

+        return !f.IsDir() && !strings.HasPrefix(name, ".") && strings.HasSuffix(name, ".go")
 }
 
 func diff(b1, b2 []byte) (data []byte, err error) {
         f1, err := ioutil.TempFile("", "gofix")
         if err != nil {
                 return nil, err
         }
         defer os.Remove(f1.Name())
         defer f1.Close()
 
         f2, err := ioutil.TempFile("", "gofix")
         if err != nil {
                 return nil, err
         }
         defer os.Remove(f2.Name())
         defer f2.Close()
 
         f1.Write(b1)
         f2.Write(b2)
 
         data, err = exec.Command("diff", "-u", f1.Name(), f2.Name()).CombinedOutput()
         if len(data) > 0 {
                 // diff exits with a non-zero status when the files don't match.
                 // Ignore that failure as long as we get output.
                 err = nil
         }
         return
 }