code review 4607052: os.Error API: don't export os.ErrorString, use os.NewEr...

src/cmd/gofix/testdata/reflect.export.go.out

 // 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.
 
 /*
         The netchan package implements type-safe networked channels:
         it allows the two ends of a channel to appear on different
         computers connected by a network.  It does this by transporting
         data sent to a channel on one machine so it can be recovered
         by a receive of a channel of the same type on the other.
@@ skipping 325 matching lines @@
 // positive and Sync takes longer than that to complete, an error is
 // returned.
 func (exp *Exporter) Sync(timeout int64) os.Error {
         // This wrapper function is here so the method's comment will appear in godoc.
         return exp.clientSet.sync(timeout)
 }
 
 func checkChan(chT interface{}, dir Dir) (reflect.Value, os.Error) {
         chanType := reflect.TypeOf(chT)
         if chanType.Kind() != reflect.Chan {
-                return reflect.Value{}, os.ErrorString("not a channel")
+                return reflect.Value{}, os.NewError("not a channel")
         }
         if dir != Send && dir != Recv {
-                return reflect.Value{}, os.ErrorString("unknown channel direction")
+                return reflect.Value{}, os.NewError("unknown channel direction")
         }
         switch chanType.ChanDir() {
         case reflect.BothDir:
         case reflect.SendDir:
                 if dir != Recv {
-                        return reflect.Value{}, os.ErrorString("to import/export with Send, must provide <-chan")
+                        return reflect.Value{}, os.NewError("to import/export with Send, must provide <-chan")
                 }
         case reflect.RecvDir:
                 if dir != Send {
-                        return reflect.Value{}, os.ErrorString("to import/export with Recv, must provide chan<-")
+                        return reflect.Value{}, os.NewError("to import/export with Recv, must provide chan<-")
                 }
         }
         return reflect.ValueOf(chT), nil
 }
 
 // Export exports a channel of a given type and specified direction.  The
 // channel to be exported is provided in the call and may be of arbitrary
 // channel type.
 // Despite the literal signature, the effective signature is
 //      Export(name string, chT chan T, dir Dir)
 func (exp *Exporter) Export(name string, chT interface{}, dir Dir) os.Error {
         ch, err := checkChan(chT, dir)
         if err != nil {
                 return err
         }
         exp.mu.Lock()
         defer exp.mu.Unlock()
         _, present := exp.names[name]
         if present {
-                return os.ErrorString("channel name already being exported:" + name)
+                return os.NewError("channel name already being exported:" + name)
         }
         exp.names[name] = &chanDir{ch, dir}
         return nil
 }
 
 // Hangup disassociates the named channel from the Exporter and closes
 // the channel.  Messages in flight for the channel may be dropped.
 func (exp *Exporter) Hangup(name string) os.Error {
         exp.mu.Lock()
         chDir, ok := exp.names[name]
         if ok {
                 exp.names[name] = nil, false
         }
         // TODO drop all instances of channel from client sets
         exp.mu.Unlock()
         if !ok {
-                return os.ErrorString("netchan export: hangup: no such channel: " + name)
+                return os.NewError("netchan export: hangup: no such channel: " + name)
         }
         chDir.ch.Close()
         return nil
 }