code review 5298073: os: use error, io.EOF

src/pkg/os/path.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 os
 
+import "io"
+
 // MkdirAll creates a directory named path,
 // along with any necessary parents, and returns nil,
 // or else returns an error.
 // The permission bits perm are used for all
 // directories that MkdirAll creates.
 // If path is already a directory, MkdirAll does nothing
 // and returns nil.
-func MkdirAll(path string, perm uint32) Error {
+func MkdirAll(path string, perm uint32) error {
         // If path exists, stop with success or error.
         dir, err := Stat(path)
         if err == nil {
                 if dir.IsDirectory() {
                         return nil
                 }
                 return &PathError{"mkdir", path, ENOTDIR}
         }
 
         // Doesn't already exist; make sure parent does.
@@ skipping 26 matching lines @@
                 }
                 return err
         }
         return nil
 }
 
 // RemoveAll removes path and any children it contains.
 // It removes everything it can but returns the first error
 // it encounters.  If the path does not exist, RemoveAll
 // returns nil (no error).
-func RemoveAll(path string) Error {
+func RemoveAll(path string) error {
         // Simple case: if Remove works, we're done.
         err := Remove(path)
         if err == nil {
                 return nil
         }
 
         // Otherwise, is this a directory we need to recurse into?
         dir, serr := Lstat(path)
         if serr != nil {
-                if serr, ok := serr.(*PathError); ok && (serr.Error == ENOENT || serr.Error == ENOTDIR) {
+                if serr, ok := serr.(*PathError); ok && (serr.Err == ENOENT || serr.Err == ENOTDIR) {
                         return nil
                 }
                 return serr
         }
         if !dir.IsDirectory() {
                 // Not a directory; return the error from Remove.
                 return err
         }
 
         // Directory.
         fd, err := Open(path)
         if err != nil {
                 return err
         }
 
         // Remove contents & return first error.
         err = nil
         for {
                 names, err1 := fd.Readdirnames(100)
                 for _, name := range names {
                         err1 := RemoveAll(path + string(PathSeparator) + name)
                         if err == nil {
                                 err = err1
                         }
                 }
-                if err1 == EOF {
+                if err1 == io.EOF {
                         break
                 }
                 // If Readdirnames returned an error, use it.
                 if err == nil {
                         err = err1
                 }
                 if len(names) == 0 {
                         break
                 }
         }
 
         // Close directory, because windows won't remove opened directory.
         fd.Close()
 
         // Remove directory.
         err1 := Remove(path)
         if err == nil {
                 err = err1
         }
         return err
 }