libgo: Update to weekly.2011-11-02.

From-SVN: r181964

7 files changed, 151 insertions, 153 deletions

diff --git a/libgo/go/rpc/client.go b/libgo/go/rpc/client.go
index 3dc6df1..ecc84de 100644
--- a/libgo/go/rpc/client.go
+++ b/libgo/go/rpc/client.go
@@ -6,12 +6,12 @@ package rpc
 
 import (
 	"bufio"
+	"errors"
 	"gob"
 	"http"
 	"io"
 	"log"
 	"net"
-	"os"
 	"sync"
 )
 
@@ -19,18 +19,18 @@ import (
 // the remote side of the RPC connection.
 type ServerError string
 
-func (e ServerError) String() string {
+func (e ServerError) Error() string {
 	return string(e)
 }
 
-var ErrShutdown = os.NewError("connection is shut down")
+var ErrShutdown = errors.New("connection is shut down")
 
 // Call represents an active RPC.
 type Call struct {
 	ServiceMethod string      // The name of the service and method to call.
 	Args          interface{} // The argument to the function (*struct).
 	Reply         interface{} // The reply from the function (*struct).
-	Error         os.Error    // After completion, the error status.
+	Error         error       // After completion, the error status.
 	Done          chan *Call  // Strobes when call is complete; value is the error status.
 	seq           uint64
 }
@@ -58,11 +58,11 @@ type Client struct {
 // argument to force the body of the response to be read and then
 // discarded.
 type ClientCodec interface {
-	WriteRequest(*Request, interface{}) os.Error
-	ReadResponseHeader(*Response) os.Error
-	ReadResponseBody(interface{}) os.Error
+	WriteRequest(*Request, interface{}) error
+	ReadResponseHeader(*Response) error
+	ReadResponseBody(interface{}) error
 
-	Close() os.Error
+	Close() error
 }
 
 func (client *Client) send(c *Call) {
@@ -91,13 +91,13 @@ func (client *Client) send(c *Call) {
 }
 
 func (client *Client) input() {
-	var err os.Error
+	var err error
 	var response Response
 	for err == nil {
 		response = Response{}
 		err = client.codec.ReadResponseHeader(&response)
 		if err != nil {
-			if err == os.EOF && !client.closing {
+			if err == io.EOF && !client.closing {
 				err = io.ErrUnexpectedEOF
 			}
 			break
@@ -111,7 +111,7 @@ func (client *Client) input() {
 		if response.Error == "" {
 			err = client.codec.ReadResponseBody(c.Reply)
 			if err != nil {
-				c.Error = os.NewError("reading body " + err.String())
+				c.Error = errors.New("reading body " + err.Error())
 			}
 		} else {
 			// We've got an error response. Give this to the request;
@@ -120,7 +120,7 @@ func (client *Client) input() {
 			c.Error = ServerError(response.Error)
 			err = client.codec.ReadResponseBody(nil)
 			if err != nil {
-				err = os.NewError("reading error body: " + err.String())
+				err = errors.New("reading error body: " + err.Error())
 			}
 		}
 		c.done()
@@ -133,7 +133,7 @@ func (client *Client) input() {
 		call.done()
 	}
 	client.mutex.Unlock()
-	if err != os.EOF || !client.closing {
+	if err != io.EOF || !client.closing {
 		log.Println("rpc: client protocol error:", err)
 	}
 }
@@ -176,7 +176,7 @@ type gobClientCodec struct {
 	encBuf *bufio.Writer
 }
 
-func (c *gobClientCodec) WriteRequest(r *Request, body interface{}) (err os.Error) {
+func (c *gobClientCodec) WriteRequest(r *Request, body interface{}) (err error) {
 	if err = c.enc.Encode(r); err != nil {
 		return
 	}
@@ -186,28 +186,28 @@ func (c *gobClientCodec) WriteRequest(r *Request, body interface{}) (err os.Erro
 	return c.encBuf.Flush()
 }
 
-func (c *gobClientCodec) ReadResponseHeader(r *Response) os.Error {
+func (c *gobClientCodec) ReadResponseHeader(r *Response) error {
 	return c.dec.Decode(r)
 }
 
-func (c *gobClientCodec) ReadResponseBody(body interface{}) os.Error {
+func (c *gobClientCodec) ReadResponseBody(body interface{}) error {
 	return c.dec.Decode(body)
 }
 
-func (c *gobClientCodec) Close() os.Error {
+func (c *gobClientCodec) Close() error {
 	return c.rwc.Close()
 }
 
 // DialHTTP connects to an HTTP RPC server at the specified network address
 // listening on the default HTTP RPC path.
-func DialHTTP(network, address string) (*Client, os.Error) {
+func DialHTTP(network, address string) (*Client, error) {
 	return DialHTTPPath(network, address, DefaultRPCPath)
 }
 
 // DialHTTPPath connects to an HTTP RPC server 
 // at the specified network address and path.
-func DialHTTPPath(network, address, path string) (*Client, os.Error) {
-	var err os.Error
+func DialHTTPPath(network, address, path string) (*Client, error) {
+	var err error
 	conn, err := net.Dial(network, address)
 	if err != nil {
 		return nil, err
@@ -221,14 +221,14 @@ func DialHTTPPath(network, address, path string) (*Client, os.Error) {
 		return NewClient(conn), nil
 	}
 	if err == nil {
-		err = os.NewError("unexpected HTTP response: " + resp.Status)
+		err = errors.New("unexpected HTTP response: " + resp.Status)
 	}
 	conn.Close()
 	return nil, &net.OpError{"dial-http", network + " " + address, nil, err}
 }
 
 // Dial connects to an RPC server at the specified network address.
-func Dial(network, address string) (*Client, os.Error) {
+func Dial(network, address string) (*Client, error) {
 	conn, err := net.Dial(network, address)
 	if err != nil {
 		return nil, err
@@ -236,7 +236,7 @@ func Dial(network, address string) (*Client, os.Error) {
 	return NewClient(conn), nil
 }
 
-func (client *Client) Close() os.Error {
+func (client *Client) Close() error {
 	client.mutex.Lock()
 	if client.shutdown || client.closing {
 		client.mutex.Unlock()
@@ -278,7 +278,7 @@ func (client *Client) Go(serviceMethod string, args interface{}, reply interface
 }
 
 // Call invokes the named function, waits for it to complete, and returns its error status.
-func (client *Client) Call(serviceMethod string, args interface{}, reply interface{}) os.Error {
+func (client *Client) Call(serviceMethod string, args interface{}, reply interface{}) error {
 	if client.shutdown {
 		return ErrShutdown
 	}
diff --git a/libgo/go/rpc/debug.go b/libgo/go/rpc/debug.go
index 7e3e6f6..02d577f 100644
--- a/libgo/go/rpc/debug.go
+++ b/libgo/go/rpc/debug.go
@@ -27,7 +27,7 @@ const debugText = `<html>
 		<th align=center>Method</th><th align=center>Calls</th>
 		{{range .Method}}
 			<tr>
-			<td align=left font=fixed>{{.Name}}({{.Type.ArgType}}, {{.Type.ReplyType}}) os.Error</td>
+			<td align=left font=fixed>{{.Name}}({{.Type.ArgType}}, {{.Type.ReplyType}}) error</td>
 			<td align=center>{{.Type.NumCalls}}</td>
 			</tr>
 		{{end}}
@@ -85,6 +85,6 @@ func (server debugHTTP) ServeHTTP(w http.ResponseWriter, req *http.Request) {
 	sort.Sort(services)
 	err := debug.Execute(w, services)
 	if err != nil {
-		fmt.Fprintln(w, "rpc: error executing template:", err.String())
+		fmt.Fprintln(w, "rpc: error executing template:", err.Error())
 	}
 }
diff --git a/libgo/go/rpc/jsonrpc/all_test.go b/libgo/go/rpc/jsonrpc/all_test.go
index 99253ba..1451a0f 100644
--- a/libgo/go/rpc/jsonrpc/all_test.go
+++ b/libgo/go/rpc/jsonrpc/all_test.go
@@ -5,11 +5,11 @@
 package jsonrpc
 
 import (
+	"errors"
 	"fmt"
 	"io"
 	"json"
 	"net"
-	"os"
 	"rpc"
 	"testing"
 )
@@ -24,25 +24,25 @@ type Reply struct {
 
 type Arith int
 
-func (t *Arith) Add(args *Args, reply *Reply) os.Error {
+func (t *Arith) Add(args *Args, reply *Reply) error {
 	reply.C = args.A + args.B
 	return nil
 }
 
-func (t *Arith) Mul(args *Args, reply *Reply) os.Error {
+func (t *Arith) Mul(args *Args, reply *Reply) error {
 	reply.C = args.A * args.B
 	return nil
 }
 
-func (t *Arith) Div(args *Args, reply *Reply) os.Error {
+func (t *Arith) Div(args *Args, reply *Reply) error {
 	if args.B == 0 {
-		return os.NewError("divide by zero")
+		return errors.New("divide by zero")
 	}
 	reply.C = args.A / args.B
 	return nil
 }
 
-func (t *Arith) Error(args *Args, reply *Reply) os.Error {
+func (t *Arith) Error(args *Args, reply *Reply) error {
 	panic("ERROR")
 }
 
@@ -105,7 +105,7 @@ func TestClient(t *testing.T) {
 	reply := new(Reply)
 	err := client.Call("Arith.Add", args, reply)
 	if err != nil {
-		t.Errorf("Add: expected no error but got string %q", err.String())
+		t.Errorf("Add: expected no error but got string %q", err.Error())
 	}
 	if reply.C != args.A+args.B {
 		t.Errorf("Add: expected %d got %d", reply.C, args.A+args.B)
@@ -115,7 +115,7 @@ func TestClient(t *testing.T) {
 	reply = new(Reply)
 	err = client.Call("Arith.Mul", args, reply)
 	if err != nil {
-		t.Errorf("Mul: expected no error but got string %q", err.String())
+		t.Errorf("Mul: expected no error but got string %q", err.Error())
 	}
 	if reply.C != args.A*args.B {
 		t.Errorf("Mul: expected %d got %d", reply.C, args.A*args.B)
@@ -130,7 +130,7 @@ func TestClient(t *testing.T) {
 
 	addCall = <-addCall.Done
 	if addCall.Error != nil {
-		t.Errorf("Add: expected no error but got string %q", addCall.Error.String())
+		t.Errorf("Add: expected no error but got string %q", addCall.Error.Error())
 	}
 	if addReply.C != args.A+args.B {
 		t.Errorf("Add: expected %d got %d", addReply.C, args.A+args.B)
@@ -138,7 +138,7 @@ func TestClient(t *testing.T) {
 
 	mulCall = <-mulCall.Done
 	if mulCall.Error != nil {
-		t.Errorf("Mul: expected no error but got string %q", mulCall.Error.String())
+		t.Errorf("Mul: expected no error but got string %q", mulCall.Error.Error())
 	}
 	if mulReply.C != args.A*args.B {
 		t.Errorf("Mul: expected %d got %d", mulReply.C, args.A*args.B)
@@ -151,7 +151,7 @@ func TestClient(t *testing.T) {
 	// expect an error: zero divide
 	if err == nil {
 		t.Error("Div: expected error")
-	} else if err.String() != "divide by zero" {
+	} else if err.Error() != "divide by zero" {
 		t.Error("Div: expected divide by zero error; got", err)
 	}
 }
@@ -164,8 +164,8 @@ func TestMalformedInput(t *testing.T) {
 
 func TestUnexpectedError(t *testing.T) {
 	cli, srv := myPipe()
-	go cli.PipeWriter.CloseWithError(os.NewError("unexpected error!")) // reader will get this error
-	ServeConn(srv)                                                     // must return, not loop
+	go cli.PipeWriter.CloseWithError(errors.New("unexpected error!")) // reader will get this error
+	ServeConn(srv)                                                    // must return, not loop
 }
 
 // Copied from package net.
@@ -191,7 +191,7 @@ func (pipeAddr) String() string {
 	return "pipe"
 }
 
-func (p *pipe) Close() os.Error {
+func (p *pipe) Close() error {
 	err := p.PipeReader.Close()
 	err1 := p.PipeWriter.Close()
 	if err == nil {
@@ -208,14 +208,14 @@ func (p *pipe) RemoteAddr() net.Addr {
 	return pipeAddr(0)
 }
 
-func (p *pipe) SetTimeout(nsec int64) os.Error {
-	return os.NewError("net.Pipe does not support timeouts")
+func (p *pipe) SetTimeout(nsec int64) error {
+	return errors.New("net.Pipe does not support timeouts")
 }
 
-func (p *pipe) SetReadTimeout(nsec int64) os.Error {
-	return os.NewError("net.Pipe does not support timeouts")
+func (p *pipe) SetReadTimeout(nsec int64) error {
+	return errors.New("net.Pipe does not support timeouts")
 }
 
-func (p *pipe) SetWriteTimeout(nsec int64) os.Error {
-	return os.NewError("net.Pipe does not support timeouts")
+func (p *pipe) SetWriteTimeout(nsec int64) error {
+	return errors.New("net.Pipe does not support timeouts")
 }
diff --git a/libgo/go/rpc/jsonrpc/client.go b/libgo/go/rpc/jsonrpc/client.go
index 17e9b93..f0475f0 100644
--- a/libgo/go/rpc/jsonrpc/client.go
+++ b/libgo/go/rpc/jsonrpc/client.go
@@ -11,7 +11,6 @@ import (
 	"io"
 	"json"
 	"net"
-	"os"
 	"rpc"
 	"sync"
 )
@@ -49,7 +48,7 @@ type clientRequest struct {
 	Id     uint64         `json:"id"`
 }
 
-func (c *clientCodec) WriteRequest(r *rpc.Request, param interface{}) os.Error {
+func (c *clientCodec) WriteRequest(r *rpc.Request, param interface{}) error {
 	c.mutex.Lock()
 	c.pending[r.Seq] = r.ServiceMethod
 	c.mutex.Unlock()
@@ -71,7 +70,7 @@ func (r *clientResponse) reset() {
 	r.Error = nil
 }
 
-func (c *clientCodec) ReadResponseHeader(r *rpc.Response) os.Error {
+func (c *clientCodec) ReadResponseHeader(r *rpc.Response) error {
 	c.resp.reset()
 	if err := c.dec.Decode(&c.resp); err != nil {
 		return err
@@ -97,14 +96,14 @@ func (c *clientCodec) ReadResponseHeader(r *rpc.Response) os.Error {
 	return nil
 }
 
-func (c *clientCodec) ReadResponseBody(x interface{}) os.Error {
+func (c *clientCodec) ReadResponseBody(x interface{}) error {
 	if x == nil {
 		return nil
 	}
 	return json.Unmarshal(*c.resp.Result, x)
 }
 
-func (c *clientCodec) Close() os.Error {
+func (c *clientCodec) Close() error {
 	return c.c.Close()
 }
 
@@ -115,7 +114,7 @@ func NewClient(conn io.ReadWriteCloser) *rpc.Client {
 }
 
 // Dial connects to a JSON-RPC server at the specified network address.
-func Dial(network, address string) (*rpc.Client, os.Error) {
+func Dial(network, address string) (*rpc.Client, error) {
 	conn, err := net.Dial(network, address)
 	if err != nil {
 		return nil, err
diff --git a/libgo/go/rpc/jsonrpc/server.go b/libgo/go/rpc/jsonrpc/server.go
index 61b5abf..9fe3470 100644
--- a/libgo/go/rpc/jsonrpc/server.go
+++ b/libgo/go/rpc/jsonrpc/server.go
@@ -5,9 +5,9 @@
 package jsonrpc
 
 import (
+	"errors"
 	"io"
 	"json"
-	"os"
 	"rpc"
 	"sync"
 )
@@ -64,7 +64,7 @@ type serverResponse struct {
 	Error  interface{}      `json:"error"`
 }
 
-func (c *serverCodec) ReadRequestHeader(r *rpc.Request) os.Error {
+func (c *serverCodec) ReadRequestHeader(r *rpc.Request) error {
 	c.req.reset()
 	if err := c.dec.Decode(&c.req); err != nil {
 		return err
@@ -84,7 +84,7 @@ func (c *serverCodec) ReadRequestHeader(r *rpc.Request) os.Error {
 	return nil
 }
 
-func (c *serverCodec) ReadRequestBody(x interface{}) os.Error {
+func (c *serverCodec) ReadRequestBody(x interface{}) error {
 	if x == nil {
 		return nil
 	}
@@ -99,13 +99,13 @@ func (c *serverCodec) ReadRequestBody(x interface{}) os.Error {
 
 var null = json.RawMessage([]byte("null"))
 
-func (c *serverCodec) WriteResponse(r *rpc.Response, x interface{}) os.Error {
+func (c *serverCodec) WriteResponse(r *rpc.Response, x interface{}) error {
 	var resp serverResponse
 	c.mutex.Lock()
 	b, ok := c.pending[r.Seq]
 	if !ok {
 		c.mutex.Unlock()
-		return os.NewError("invalid sequence number in response")
+		return errors.New("invalid sequence number in response")
 	}
 	delete(c.pending, r.Seq)
 	c.mutex.Unlock()
@@ -124,7 +124,7 @@ func (c *serverCodec) WriteResponse(r *rpc.Response, x interface{}) os.Error {
 	return c.enc.Encode(resp)
 }
 
-func (c *serverCodec) Close() os.Error {
+func (c *serverCodec) Close() error {
 	return c.c.Close()
 }
 
diff --git a/libgo/go/rpc/server.go b/libgo/go/rpc/server.go
index 71797e2..d031533 100644
--- a/libgo/go/rpc/server.go
+++ b/libgo/go/rpc/server.go
@@ -18,12 +18,12 @@
 		  registering the service).
 		- the method has two arguments, both exported or local types.
 		- the method's second argument is a pointer.
-		- the method has return type os.Error.
+		- the method has return type error.
 
 	The method's first argument represents the arguments provided by the caller; the
 	second argument represents the result parameters to be returned to the caller.
 	The method's return value, if non-nil, is passed back as a string that the client
-	sees as an os.ErrorString.
+	sees as if created by errors.New.
 
 	The server may handle requests on a single connection by calling ServeConn.  More
 	typically it will create a network listener and call Accept or, for an HTTP
@@ -55,14 +55,14 @@
 
 		type Arith int
 
-		func (t *Arith) Multiply(args *Args, reply *int) os.Error {
+		func (t *Arith) Multiply(args *Args, reply *int) error {
 			*reply = args.A * args.B
 			return nil
 		}
 
-		func (t *Arith) Divide(args *Args, quo *Quotient) os.Error {
+		func (t *Arith) Divide(args *Args, quo *Quotient) error {
 			if args.B == 0 {
-				return os.ErrorString("divide by zero")
+				return errors.New("divide by zero")
 			}
 			quo.Quo = args.A / args.B
 			quo.Rem = args.A % args.B
@@ -114,12 +114,12 @@ package rpc
 
 import (
 	"bufio"
+	"errors"
 	"gob"
 	"http"
 	"io"
 	"log"
 	"net"
-	"os"
 	"reflect"
 	"strings"
 	"sync"
@@ -133,10 +133,9 @@ const (
 	DefaultDebugPath = "/debug/rpc"
 )
 
-// Precompute the reflect type for os.Error.  Can't use os.Error directly
+// Precompute the reflect type for error.  Can't use error directly
 // because Typeof takes an empty interface value.  This is annoying.
-var unusedError *os.Error
-var typeOfOsError = reflect.TypeOf(unusedError).Elem()
+var typeOfError = reflect.TypeOf((*error)(nil)).Elem()
 
 type methodType struct {
 	sync.Mutex // protects counters
@@ -210,22 +209,22 @@ func isExportedOrBuiltinType(t reflect.Type) bool {
 // receiver value that satisfy the following conditions:
 //	- exported method
 //	- two arguments, both pointers to exported structs
-//	- one return value, of type os.Error
+//	- one return value, of type error
 // It returns an error if the receiver is not an exported type or has no
 // suitable methods.
 // The client accesses each method using a string of the form "Type.Method",
 // where Type is the receiver's concrete type.
-func (server *Server) Register(rcvr interface{}) os.Error {
+func (server *Server) Register(rcvr interface{}) error {
 	return server.register(rcvr, "", false)
 }
 
 // RegisterName is like Register but uses the provided name for the type 
 // instead of the receiver's concrete type.
-func (server *Server) RegisterName(name string, rcvr interface{}) os.Error {
+func (server *Server) RegisterName(name string, rcvr interface{}) error {
 	return server.register(rcvr, name, true)
 }
 
-func (server *Server) register(rcvr interface{}, name string, useName bool) os.Error {
+func (server *Server) register(rcvr interface{}, name string, useName bool) error {
 	server.mu.Lock()
 	defer server.mu.Unlock()
 	if server.serviceMap == nil {
@@ -244,10 +243,10 @@ func (server *Server) register(rcvr interface{}, name string, useName bool) os.E
 	if !isExported(sname) && !useName {
 		s := "rpc Register: type " + sname + " is not exported"
 		log.Print(s)
-		return os.NewError(s)
+		return errors.New(s)
 	}
 	if _, present := server.serviceMap[sname]; present {
-		return os.NewError("rpc: service already defined: " + sname)
+		return errors.New("rpc: service already defined: " + sname)
 	}
 	s.name = sname
 	s.method = make(map[string]*methodType)
@@ -281,13 +280,13 @@ func (server *Server) register(rcvr interface{}, name string, useName bool) os.E
 			log.Println("method", mname, "reply type not exported or local:", replyType)
 			continue
 		}
-		// Method needs one out: os.Error.
+		// Method needs one out: error.
 		if mtype.NumOut() != 1 {
 			log.Println("method", mname, "has wrong number of outs:", mtype.NumOut())
 			continue
 		}
-		if returnType := mtype.Out(0); returnType != typeOfOsError {
-			log.Println("method", mname, "returns", returnType.String(), "not os.Error")
+		if returnType := mtype.Out(0); returnType != typeOfError {
+			log.Println("method", mname, "returns", returnType.String(), "not error")
 			continue
 		}
 		s.method[mname] = &methodType{method: method, ArgType: argType, ReplyType: replyType}
@@ -296,7 +295,7 @@ func (server *Server) register(rcvr interface{}, name string, useName bool) os.E
 	if len(s.method) == 0 {
 		s := "rpc Register: type " + sname + " has no exported methods of suitable type"
 		log.Print(s)
-		return os.NewError(s)
+		return errors.New(s)
 	}
 	server.serviceMap[s.name] = s
 	return nil
@@ -339,11 +338,11 @@ func (s *service) call(server *Server, sending *sync.Mutex, mtype *methodType, r
 	function := mtype.method.Func
 	// Invoke the method, providing a new value for the reply.
 	returnValues := function.Call([]reflect.Value{s.rcvr, argv, replyv})
-	// The return value for the method is an os.Error.
+	// The return value for the method is an error.
 	errInter := returnValues[0].Interface()
 	errmsg := ""
 	if errInter != nil {
-		errmsg = errInter.(os.Error).String()
+		errmsg = errInter.(error).Error()
 	}
 	server.sendResponse(sending, req, replyv.Interface(), codec, errmsg)
 	server.freeRequest(req)
@@ -356,15 +355,15 @@ type gobServerCodec struct {
 	encBuf *bufio.Writer
 }
 
-func (c *gobServerCodec) ReadRequestHeader(r *Request) os.Error {
+func (c *gobServerCodec) ReadRequestHeader(r *Request) error {
 	return c.dec.Decode(r)
 }
 
-func (c *gobServerCodec) ReadRequestBody(body interface{}) os.Error {
+func (c *gobServerCodec) ReadRequestBody(body interface{}) error {
 	return c.dec.Decode(body)
 }
 
-func (c *gobServerCodec) WriteResponse(r *Response, body interface{}) (err os.Error) {
+func (c *gobServerCodec) WriteResponse(r *Response, body interface{}) (err error) {
 	if err = c.enc.Encode(r); err != nil {
 		return
 	}
@@ -374,7 +373,7 @@ func (c *gobServerCodec) WriteResponse(r *Response, body interface{}) (err os.Er
 	return c.encBuf.Flush()
 }
 
-func (c *gobServerCodec) Close() os.Error {
+func (c *gobServerCodec) Close() error {
 	return c.rwc.Close()
 }
 
@@ -396,7 +395,7 @@ func (server *Server) ServeCodec(codec ServerCodec) {
 	for {
 		service, mtype, req, argv, replyv, keepReading, err := server.readRequest(codec)
 		if err != nil {
-			if err != os.EOF {
+			if err != io.EOF {
 				log.Println("rpc:", err)
 			}
 			if !keepReading {
@@ -404,7 +403,7 @@ func (server *Server) ServeCodec(codec ServerCodec) {
 			}
 			// send a response if we actually managed to read a header.
 			if req != nil {
-				server.sendResponse(sending, req, invalidRequest, codec, err.String())
+				server.sendResponse(sending, req, invalidRequest, codec, err.Error())
 				server.freeRequest(req)
 			}
 			continue
@@ -416,7 +415,7 @@ func (server *Server) ServeCodec(codec ServerCodec) {
 
 // ServeRequest is like ServeCodec but synchronously serves a single request.
 // It does not close the codec upon completion.
-func (server *Server) ServeRequest(codec ServerCodec) os.Error {
+func (server *Server) ServeRequest(codec ServerCodec) error {
 	sending := new(sync.Mutex)
 	service, mtype, req, argv, replyv, keepReading, err := server.readRequest(codec)
 	if err != nil {
@@ -425,7 +424,7 @@ func (server *Server) ServeRequest(codec ServerCodec) os.Error {
 		}
 		// send a response if we actually managed to read a header.
 		if req != nil {
-			server.sendResponse(sending, req, invalidRequest, codec, err.String())
+			server.sendResponse(sending, req, invalidRequest, codec, err.Error())
 			server.freeRequest(req)
 		}
 		return err
@@ -474,7 +473,7 @@ func (server *Server) freeResponse(resp *Response) {
 	server.respLock.Unlock()
 }
 
-func (server *Server) readRequest(codec ServerCodec) (service *service, mtype *methodType, req *Request, argv, replyv reflect.Value, keepReading bool, err os.Error) {
+func (server *Server) readRequest(codec ServerCodec) (service *service, mtype *methodType, req *Request, argv, replyv reflect.Value, keepReading bool, err error) {
 	service, mtype, req, keepReading, err = server.readRequestHeader(codec)
 	if err != nil {
 		if !keepReading {
@@ -505,16 +504,16 @@ func (server *Server) readRequest(codec ServerCodec) (service *service, mtype *m
 	return
 }
 
-func (server *Server) readRequestHeader(codec ServerCodec) (service *service, mtype *methodType, req *Request, keepReading bool, err os.Error) {
+func (server *Server) readRequestHeader(codec ServerCodec) (service *service, mtype *methodType, req *Request, keepReading bool, err error) {
 	// Grab the request header.
 	req = server.getRequest()
 	err = codec.ReadRequestHeader(req)
 	if err != nil {
 		req = nil
-		if err == os.EOF || err == io.ErrUnexpectedEOF {
+		if err == io.EOF || err == io.ErrUnexpectedEOF {
 			return
 		}
-		err = os.NewError("rpc: server cannot decode request: " + err.String())
+		err = errors.New("rpc: server cannot decode request: " + err.Error())
 		return
 	}
 
@@ -524,7 +523,7 @@ func (server *Server) readRequestHeader(codec ServerCodec) (service *service, mt
 
 	serviceMethod := strings.Split(req.ServiceMethod, ".")
 	if len(serviceMethod) != 2 {
-		err = os.NewError("rpc: service/method request ill-formed: " + req.ServiceMethod)
+		err = errors.New("rpc: service/method request ill-formed: " + req.ServiceMethod)
 		return
 	}
 	// Look up the request.
@@ -532,12 +531,12 @@ func (server *Server) readRequestHeader(codec ServerCodec) (service *service, mt
 	service = server.serviceMap[serviceMethod[0]]
 	server.mu.Unlock()
 	if service == nil {
-		err = os.NewError("rpc: can't find service " + req.ServiceMethod)
+		err = errors.New("rpc: can't find service " + req.ServiceMethod)
 		return
 	}
 	mtype = service.method[serviceMethod[1]]
 	if mtype == nil {
-		err = os.NewError("rpc: can't find method " + req.ServiceMethod)
+		err = errors.New("rpc: can't find method " + req.ServiceMethod)
 	}
 	return
 }
@@ -549,18 +548,18 @@ func (server *Server) Accept(lis net.Listener) {
 	for {
 		conn, err := lis.Accept()
 		if err != nil {
-			log.Fatal("rpc.Serve: accept:", err.String()) // TODO(r): exit?
+			log.Fatal("rpc.Serve: accept:", err.Error()) // TODO(r): exit?
 		}
 		go server.ServeConn(conn)
 	}
 }
 
 // Register publishes the receiver's methods in the DefaultServer.
-func Register(rcvr interface{}) os.Error { return DefaultServer.Register(rcvr) }
+func Register(rcvr interface{}) error { return DefaultServer.Register(rcvr) }
 
 // RegisterName is like Register but uses the provided name for the type 
 // instead of the receiver's concrete type.
-func RegisterName(name string, rcvr interface{}) os.Error {
+func RegisterName(name string, rcvr interface{}) error {
 	return DefaultServer.RegisterName(name, rcvr)
 }
 
@@ -572,11 +571,11 @@ func RegisterName(name string, rcvr interface{}) os.Error {
 // connection. ReadRequestBody may be called with a nil
 // argument to force the body of the request to be read and discarded.
 type ServerCodec interface {
-	ReadRequestHeader(*Request) os.Error
-	ReadRequestBody(interface{}) os.Error
-	WriteResponse(*Response, interface{}) os.Error
+	ReadRequestHeader(*Request) error
+	ReadRequestBody(interface{}) error
+	WriteResponse(*Response, interface{}) error
 
-	Close() os.Error
+	Close() error
 }
 
 // ServeConn runs the DefaultServer on a single connection.
@@ -596,7 +595,7 @@ func ServeCodec(codec ServerCodec) {
 
 // ServeRequest is like ServeCodec but synchronously serves a single request.
 // It does not close the codec upon completion.
-func ServeRequest(codec ServerCodec) os.Error {
+func ServeRequest(codec ServerCodec) error {
 	return DefaultServer.ServeRequest(codec)
 }
 
@@ -618,7 +617,7 @@ func (server *Server) ServeHTTP(w http.ResponseWriter, req *http.Request) {
 	}
 	conn, _, err := w.(http.Hijacker).Hijack()
 	if err != nil {
-		log.Print("rpc hijacking ", req.RemoteAddr, ": ", err.String())
+		log.Print("rpc hijacking ", req.RemoteAddr, ": ", err.Error())
 		return
 	}
 	io.WriteString(conn, "HTTP/1.0 "+connected+"\n\n")
diff --git a/libgo/go/rpc/server_test.go b/libgo/go/rpc/server_test.go
index 3e9fe29..119de7f 100644
--- a/libgo/go/rpc/server_test.go
+++ b/libgo/go/rpc/server_test.go
@@ -5,12 +5,12 @@
 package rpc
 
 import (
+	"errors"
 	"fmt"
 	"http/httptest"
 	"io"
 	"log"
 	"net"
-	"os"
 	"runtime"
 	"strings"
 	"sync"
@@ -43,35 +43,35 @@ type Arith int
 
 // Some of Arith's methods have value args, some have pointer args. That's deliberate.
 
-func (t *Arith) Add(args Args, reply *Reply) os.Error {
+func (t *Arith) Add(args Args, reply *Reply) error {
 	reply.C = args.A + args.B
 	return nil
 }
 
-func (t *Arith) Mul(args *Args, reply *Reply) os.Error {
+func (t *Arith) Mul(args *Args, reply *Reply) error {
 	reply.C = args.A * args.B
 	return nil
 }
 
-func (t *Arith) Div(args Args, reply *Reply) os.Error {
+func (t *Arith) Div(args Args, reply *Reply) error {
 	if args.B == 0 {
-		return os.NewError("divide by zero")
+		return errors.New("divide by zero")
 	}
 	reply.C = args.A / args.B
 	return nil
 }
 
-func (t *Arith) String(args *Args, reply *string) os.Error {
+func (t *Arith) String(args *Args, reply *string) error {
 	*reply = fmt.Sprintf("%d+%d=%d", args.A, args.B, args.A+args.B)
 	return nil
 }
 
-func (t *Arith) Scan(args string, reply *Reply) (err os.Error) {
+func (t *Arith) Scan(args string, reply *Reply) (err error) {
 	_, err = fmt.Sscan(args, &reply.C)
 	return
 }
 
-func (t *Arith) Error(args *Args, reply *Reply) os.Error {
+func (t *Arith) Error(args *Args, reply *Reply) error {
 	panic("ERROR")
 }
 
@@ -132,7 +132,7 @@ func testRPC(t *testing.T, addr string) {
 	reply := new(Reply)
 	err = client.Call("Arith.Add", args, reply)
 	if err != nil {
-		t.Errorf("Add: expected no error but got string %q", err.String())
+		t.Errorf("Add: expected no error but got string %q", err.Error())
 	}
 	if reply.C != args.A+args.B {
 		t.Errorf("Add: expected %d got %d", reply.C, args.A+args.B)
@@ -145,7 +145,7 @@ func testRPC(t *testing.T, addr string) {
 	// expect an error
 	if err == nil {
 		t.Error("BadOperation: expected error")
-	} else if !strings.HasPrefix(err.String(), "rpc: can't find method ") {
+	} else if !strings.HasPrefix(err.Error(), "rpc: can't find method ") {
 		t.Errorf("BadOperation: expected can't find method error; got %q", err)
 	}
 
@@ -155,7 +155,7 @@ func testRPC(t *testing.T, addr string) {
 	err = client.Call("Arith.Unknown", args, reply)
 	if err == nil {
 		t.Error("expected error calling unknown service")
-	} else if strings.Index(err.String(), "method") < 0 {
+	} else if strings.Index(err.Error(), "method") < 0 {
 		t.Error("expected error about method; got", err)
 	}
 
@@ -168,7 +168,7 @@ func testRPC(t *testing.T, addr string) {
 
 	addCall = <-addCall.Done
 	if addCall.Error != nil {
-		t.Errorf("Add: expected no error but got string %q", addCall.Error.String())
+		t.Errorf("Add: expected no error but got string %q", addCall.Error.Error())
 	}
 	if addReply.C != args.A+args.B {
 		t.Errorf("Add: expected %d got %d", addReply.C, args.A+args.B)
@@ -176,7 +176,7 @@ func testRPC(t *testing.T, addr string) {
 
 	mulCall = <-mulCall.Done
 	if mulCall.Error != nil {
-		t.Errorf("Mul: expected no error but got string %q", mulCall.Error.String())
+		t.Errorf("Mul: expected no error but got string %q", mulCall.Error.Error())
 	}
 	if mulReply.C != args.A*args.B {
 		t.Errorf("Mul: expected %d got %d", mulReply.C, args.A*args.B)
@@ -189,7 +189,7 @@ func testRPC(t *testing.T, addr string) {
 	// expect an error: zero divide
 	if err == nil {
 		t.Error("Div: expected error")
-	} else if err.String() != "divide by zero" {
+	} else if err.Error() != "divide by zero" {
 		t.Error("Div: expected divide by zero error; got", err)
 	}
 
@@ -198,7 +198,7 @@ func testRPC(t *testing.T, addr string) {
 	err = client.Call("Arith.Add", reply, reply) // args, reply would be the correct thing to use
 	if err == nil {
 		t.Error("expected error calling Arith.Add with wrong arg type")
-	} else if strings.Index(err.String(), "type") < 0 {
+	} else if strings.Index(err.Error(), "type") < 0 {
 		t.Error("expected error about type; got", err)
 	}
 
@@ -208,7 +208,7 @@ func testRPC(t *testing.T, addr string) {
 	reply = new(Reply)
 	err = client.Call("Arith.Scan", &str, reply)
 	if err != nil {
-		t.Errorf("Scan: expected no error but got string %q", err.String())
+		t.Errorf("Scan: expected no error but got string %q", err.Error())
 	} else if reply.C != Val {
 		t.Errorf("Scan: expected %d got %d", Val, reply.C)
 	}
@@ -218,7 +218,7 @@ func testRPC(t *testing.T, addr string) {
 	str = ""
 	err = client.Call("Arith.String", args, &str)
 	if err != nil {
-		t.Errorf("String: expected no error but got string %q", err.String())
+		t.Errorf("String: expected no error but got string %q", err.Error())
 	}
 	expect := fmt.Sprintf("%d+%d=%d", args.A, args.B, args.A+args.B)
 	if str != expect {
@@ -229,7 +229,7 @@ func testRPC(t *testing.T, addr string) {
 	reply = new(Reply)
 	err = client.Call("Arith.Mul", args, reply)
 	if err != nil {
-		t.Errorf("Mul: expected no error but got string %q", err.String())
+		t.Errorf("Mul: expected no error but got string %q", err.Error())
 	}
 	if reply.C != args.A*args.B {
 		t.Errorf("Mul: expected %d got %d", reply.C, args.A*args.B)
@@ -245,7 +245,7 @@ func TestHTTP(t *testing.T) {
 
 func testHTTPRPC(t *testing.T, path string) {
 	var client *Client
-	var err os.Error
+	var err error
 	if path == "" {
 		client, err = DialHTTP("tcp", httpServerAddr)
 	} else {
@@ -260,7 +260,7 @@ func testHTTPRPC(t *testing.T, path string) {
 	reply := new(Reply)
 	err = client.Call("Arith.Add", args, reply)
 	if err != nil {
-		t.Errorf("Add: expected no error but got string %q", err.String())
+		t.Errorf("Add: expected no error but got string %q", err.Error())
 	}
 	if reply.C != args.A+args.B {
 		t.Errorf("Add: expected %d got %d", reply.C, args.A+args.B)
@@ -274,15 +274,15 @@ type CodecEmulator struct {
 	serviceMethod string
 	args          *Args
 	reply         *Reply
-	err           os.Error
+	err           error
 }
 
-func (codec *CodecEmulator) Call(serviceMethod string, args *Args, reply *Reply) os.Error {
+func (codec *CodecEmulator) Call(serviceMethod string, args *Args, reply *Reply) error {
 	codec.serviceMethod = serviceMethod
 	codec.args = args
 	codec.reply = reply
 	codec.err = nil
-	var serverError os.Error
+	var serverError error
 	if codec.server == nil {
 		serverError = ServeRequest(codec)
 	} else {
@@ -294,13 +294,13 @@ func (codec *CodecEmulator) Call(serviceMethod string, args *Args, reply *Reply)
 	return codec.err
 }
 
-func (codec *CodecEmulator) ReadRequestHeader(req *Request) os.Error {
+func (codec *CodecEmulator) ReadRequestHeader(req *Request) error {
 	req.ServiceMethod = codec.serviceMethod
 	req.Seq = 0
 	return nil
 }
 
-func (codec *CodecEmulator) ReadRequestBody(argv interface{}) os.Error {
+func (codec *CodecEmulator) ReadRequestBody(argv interface{}) error {
 	if codec.args == nil {
 		return io.ErrUnexpectedEOF
 	}
@@ -308,16 +308,16 @@ func (codec *CodecEmulator) ReadRequestBody(argv interface{}) os.Error {
 	return nil
 }
 
-func (codec *CodecEmulator) WriteResponse(resp *Response, reply interface{}) os.Error {
+func (codec *CodecEmulator) WriteResponse(resp *Response, reply interface{}) error {
 	if resp.Error != "" {
-		codec.err = os.NewError(resp.Error)
+		codec.err = errors.New(resp.Error)
 	} else {
 		*codec.reply = *(reply.(*Reply))
 	}
 	return nil
 }
 
-func (codec *CodecEmulator) Close() os.Error {
+func (codec *CodecEmulator) Close() error {
 	return nil
 }
 
@@ -335,7 +335,7 @@ func testServeRequest(t *testing.T, server *Server) {
 	reply := new(Reply)
 	err := client.Call("Arith.Add", args, reply)
 	if err != nil {
-		t.Errorf("Add: expected no error but got string %q", err.String())
+		t.Errorf("Add: expected no error but got string %q", err.Error())
 	}
 	if reply.C != args.A+args.B {
 		t.Errorf("Add: expected %d got %d", reply.C, args.A+args.B)
@@ -352,15 +352,15 @@ type ArgNotPublic int
 type ReplyNotPublic int
 type local struct{}
 
-func (t *ReplyNotPointer) ReplyNotPointer(args *Args, reply Reply) os.Error {
+func (t *ReplyNotPointer) ReplyNotPointer(args *Args, reply Reply) error {
 	return nil
 }
 
-func (t *ArgNotPublic) ArgNotPublic(args *local, reply *Reply) os.Error {
+func (t *ArgNotPublic) ArgNotPublic(args *local, reply *Reply) error {
 	return nil
 }
 
-func (t *ReplyNotPublic) ReplyNotPublic(args *Args, reply *local) os.Error {
+func (t *ReplyNotPublic) ReplyNotPublic(args *Args, reply *local) error {
 	return nil
 }
 
@@ -382,22 +382,22 @@ func TestRegistrationError(t *testing.T) {
 
 type WriteFailCodec int
 
-func (WriteFailCodec) WriteRequest(*Request, interface{}) os.Error {
+func (WriteFailCodec) WriteRequest(*Request, interface{}) error {
 	// the panic caused by this error used to not unlock a lock.
-	return os.NewError("fail")
+	return errors.New("fail")
 }
 
-func (WriteFailCodec) ReadResponseHeader(*Response) os.Error {
+func (WriteFailCodec) ReadResponseHeader(*Response) error {
 	time.Sleep(120e9)
 	panic("unreachable")
 }
 
-func (WriteFailCodec) ReadResponseBody(interface{}) os.Error {
+func (WriteFailCodec) ReadResponseBody(interface{}) error {
 	time.Sleep(120e9)
 	panic("unreachable")
 }
 
-func (WriteFailCodec) Close() os.Error {
+func (WriteFailCodec) Close() error {
 	return nil
 }
 
@@ -427,15 +427,15 @@ func testSendDeadlock(client *Client) {
 	client.Call("Arith.Add", args, reply)
 }
 
-func dialDirect() (*Client, os.Error) {
+func dialDirect() (*Client, error) {
 	return Dial("tcp", serverAddr)
 }
 
-func dialHTTP() (*Client, os.Error) {
+func dialHTTP() (*Client, error) {
 	return DialHTTP("tcp", httpServerAddr)
 }
 
-func countMallocs(dial func() (*Client, os.Error), t *testing.T) uint64 {
+func countMallocs(dial func() (*Client, error), t *testing.T) uint64 {
 	once.Do(startServer)
 	client, err := dial()
 	if err != nil {
@@ -449,7 +449,7 @@ func countMallocs(dial func() (*Client, os.Error), t *testing.T) uint64 {
 	for i := 0; i < count; i++ {
 		err := client.Call("Arith.Add", args, reply)
 		if err != nil {
-			t.Errorf("Add: expected no error but got string %q", err.String())
+			t.Errorf("Add: expected no error but got string %q", err.Error())
 		}
 		if reply.C != args.A+args.B {
 			t.Errorf("Add: expected %d got %d", reply.C, args.A+args.B)
@@ -470,16 +470,16 @@ func TestCountMallocsOverHTTP(t *testing.T) {
 
 type writeCrasher struct{}
 
-func (writeCrasher) Close() os.Error {
+func (writeCrasher) Close() error {
 	return nil
 }
 
-func (writeCrasher) Read(p []byte) (int, os.Error) {
-	return 0, os.EOF
+func (writeCrasher) Read(p []byte) (int, error) {
+	return 0, io.EOF
 }
 
-func (writeCrasher) Write(p []byte) (int, os.Error) {
-	return 0, os.NewError("fake write failure")
+func (writeCrasher) Write(p []byte) (int, error) {
+	return 0, errors.New("fake write failure")
 }
 
 func TestClientWriteError(t *testing.T) {
@@ -489,12 +489,12 @@ func TestClientWriteError(t *testing.T) {
 	if err == nil {
 		t.Fatal("expected error")
 	}
-	if err.String() != "fake write failure" {
+	if err.Error() != "fake write failure" {
 		t.Error("unexpected value of error:", err)
 	}
 }
 
-func benchmarkEndToEnd(dial func() (*Client, os.Error), b *testing.B) {
+func benchmarkEndToEnd(dial func() (*Client, error), b *testing.B) {
 	b.StopTimer()
 	once.Do(startServer)
 	client, err := dial()
@@ -517,7 +517,7 @@ func benchmarkEndToEnd(dial func() (*Client, os.Error), b *testing.B) {
 			for atomic.AddInt32(&N, -1) >= 0 {
 				err = client.Call("Arith.Add", args, reply)
 				if err != nil {
-					fmt.Printf("Add: expected no error but got string %q", err.String())
+					fmt.Printf("Add: expected no error but got string %q", err.Error())
 					panic("rpc error")
 				}
 				if reply.C != args.A+args.B {
@@ -531,7 +531,7 @@ func benchmarkEndToEnd(dial func() (*Client, os.Error), b *testing.B) {
 	wg.Wait()
 }
 
-func benchmarkEndToEndAsync(dial func() (*Client, os.Error), b *testing.B) {
+func benchmarkEndToEndAsync(dial func() (*Client, error), b *testing.B) {
 	const MaxConcurrentCalls = 100
 	b.StopTimer()
 	once.Do(startServer)