code review 5306075: runtime: update for error

src/pkg/runtime/error.go

 // 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.
 
 package runtime
 
 // The Error interface identifies a run time error.
 type Error interface {
-        String() string
+        error
 
         // RuntimeError is a no-op function but
         // serves to distinguish types that are runtime
         // errors from ordinary os.Errors: a type is a
         // runtime error if it has a RuntimeError method.
         RuntimeError()
 }
 
 // A TypeAssertionError explains a failed type assertion.
 type TypeAssertionError struct {
         interfaceType   Type // interface had this type
         concreteType    Type // concrete value had this type
         assertedType    Type // asserted type
         interfaceString string
         concreteString  string
         assertedString  string
         missingMethod   string // one method needed by Interface, missing from Concrete
 }
 
 func (*TypeAssertionError) RuntimeError() {}
 
-func (e *TypeAssertionError) String() string {
+func (e *TypeAssertionError) Error() string {
         inter := e.interfaceString
         if inter == "" {
                 inter = "interface"
         }
         if e.concreteType == nil {
                 return "interface conversion: " + inter + " is nil, not " + e.assertedString
         }
         if e.missingMethod == "" {
                 return "interface conversion: " + inter + " is " + e.concreteString +
                         ", not " + e.assertedString
@@ skipping 49 matching lines @@
                 meth = *pmeth
         }
         *ret = &TypeAssertionError{t1, t2, t3, s1, s2, s3, meth}
 }
 
 // An errorString represents a runtime error described by a single string.
 type errorString string
 
 func (e errorString) RuntimeError() {}
 
-func (e errorString) String() string {
+func (e errorString) Error() string {
         return "runtime error: " + string(e)
 }
 
 // For calling from C.
 func newErrorString(s string, ret *interface{}) {
         *ret = errorString(s)
 }
 
 type stringer interface {
         String() string
 }
 
 func typestring(interface{}) string
 
 // For calling from C.
 // Prints an argument passed to panic.
 // There's room for arbitrary complexity here, but we keep it
 // simple and handle just a few important cases: int, string, and Stringer.
 func printany(i interface{}) {
         switch v := i.(type) {
         case nil:
                 print("nil")
         case stringer:
                 print(v.String())
+        case error:
+                print(v.Error())
         case int:
                 print(v)
         case string:
                 print(v)
         default:
                 print("(", typestring(i), ") ", i)
         }
 }
 
 // called from generated code
 func panicwrap(pkg, typ, meth string) {
         panic("value method " + pkg + "." + typ + "." + meth + " called using nil *" + typ + " pointer")
 }