code review 5307066: non-pkg: gofix -r error

src/cmd/gofmt/gofmt.go

 // Copyright 2009 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"
         "exec"
         "flag"
@@ skipping 31 matching lines @@
 )
 
 var (
         fset        = token.NewFileSet()
         exitCode    = 0
         rewrite     func(*ast.File) *ast.File
         parserMode  uint
         printerMode uint
 )
 
-func report(err os.Error) {
+func report(err error) {
         scanner.PrintError(os.Stderr, err)
         exitCode = 2
 }
 
 func usage() {
         fmt.Fprintf(os.Stderr, "usage: gofmt [flags] [path ...]\n")
         flag.PrintDefaults()
         os.Exit(2)
 }
 
@@ skipping 16 matching lines @@
                 printerMode |= printer.UseSpaces
         }
 }
 
 func isGoFile(f *os.FileInfo) bool {
         // ignore non-Go files
         return f.IsRegular() && !strings.HasPrefix(f.Name, ".") && strings.HasSuffix(f.Name, ".go")
 }
 
 // If in == nil, the source is the contents of the file with the given filename.
-func processFile(filename string, in io.Reader, out io.Writer, stdin bool) os.Error {
+func processFile(filename string, in io.Reader, out io.Writer, stdin bool) error {
         if in == nil {
                 f, err := os.Open(filename)
                 if err != nil {
                         return err
                 }
                 defer f.Close()
                 in = f
         }
 
         src, err := ioutil.ReadAll(in)
@@ skipping 49 matching lines @@
                 }
         }
 
         if !*list && !*write && !*doDiff {
                 _, err = out.Write(res)
         }
 
         return err
 }
 
-func visitFile(path string, f *os.FileInfo, err os.Error) os.Error {
+func visitFile(path string, f *os.FileInfo, err error) error {
         if err == nil && isGoFile(f) {
                 err = processFile(path, nil, os.Stdout, false)
         }
         if err != nil {
                 report(err)
         }
         return nil
 }
 
 func walkDir(path string) {
@@ skipping 48 matching lines @@
                 case dir.IsRegular():
                         if err := processFile(path, nil, os.Stdout, false); err != nil {
                                 report(err)
                         }
                 case dir.IsDirectory():
                         walkDir(path)
                 }
         }
 }
 
-func diff(b1, b2 []byte) (data []byte, err os.Error) {
+func diff(b1, b2 []byte) (data []byte, err error) {
         f1, err := ioutil.TempFile("", "gofmt")
         if err != nil {
                 return
         }
         defer os.Remove(f1.Name())
         defer f1.Close()
 
         f2, err := ioutil.TempFile("", "gofmt")
         if err != nil {
                 return
         }
         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
 
 }
 
 // parse parses src, which was read from filename,
 // as a Go source file or statement list.
-func parse(filename string, src []byte, stdin bool) (*ast.File, func(orig, src []byte) []byte, os.Error) {
+func parse(filename string, src []byte, stdin bool) (*ast.File, func(orig, src []byte) []byte, error) {
         // Try as whole source file.
         file, err := parser.ParseFile(fset, filename, src, parserMode)
         if err == nil {
                 return file, nil, nil
         }
         // If the error is that the source file didn't begin with a
         // package line and this is standard input, fall through to
         // try as a source fragment.  Stop and return on any other error.
-        if !stdin || !strings.Contains(err.String(), "expected 'package'") {
+        if !stdin || !strings.Contains(err.Error(), "expected 'package'") {
                 return nil, nil, err
         }
 
         // If this is a declaration list, make it a source file
         // by inserting a package clause.
         // Insert using a ;, not a newline, so that the line numbers
         // in psrc match the ones in src.
         psrc := append([]byte("package p;"), src...)
         file, err = parser.ParseFile(fset, filename, psrc, parserMode)
         if err == nil {
                 adjust := func(orig, src []byte) []byte {
                         // Remove the package clause.
                         // Gofmt has turned the ; into a \n.
                         src = src[len("package p\n"):]
                         return matchSpace(orig, src)
                 }
                 return file, adjust, nil
         }
         // If the error is that the source file didn't begin with a
         // declaration, fall through to try as a statement list.
         // Stop and return on any other error.
-        if !strings.Contains(err.String(), "expected declaration") {
+        if !strings.Contains(err.Error(), "expected declaration") {
                 return nil, nil, err
         }
 
         // If this is a statement list, make it a source file
         // by inserting a package clause and turning the list
         // into a function body.  This handles expressions too.
         // Insert using a ;, not a newline, so that the line numbers
         // in fsrc match the ones in src.
         fsrc := append(append([]byte("package p; func _() {"), src...), '}')
         file, err = parser.ParseFile(fset, filename, fsrc, parserMode)
@@ skipping 53 matching lines @@
                         src = nil
                 }
                 if len(line) > 0 && line[0] != '\n' { // not blank
                         b.Write(indent)
                 }
                 b.Write(line)
         }
         b.Write(after)
         return b.Bytes()
 }