remove all references to gobType() from the decoder.

Fixes #470.

R=rsc
CC=golang-dev
https://golang.org/cl/183074

diff --git a/src/pkg/gob/decode.go b/src/pkg/gob/decode.go
index c7f314369d82690714c36098ffcc077e0869e197..41951d357f5fe98434f83c2ffd896c0bc0f660d1 100644 (file)
--- a/src/pkg/gob/decode.go
+++ b/src/pkg/gob/decode.go
@@ -540,7 +540,7 @@ func (dec *Decoder) decOpFor(wireId typeId, rt reflect.Type, name string) (decOp
 
                case *reflect.ArrayType:
                        name = "element of " + name
-                       elemId := wireId.gobType().(*arrayType).Elem
+                       elemId := dec.wireType[wireId].array.Elem
                        elemOp, elemIndir, err := dec.decOpFor(elemId, t.Elem(), name)
                        if err != nil {
                                return nil, 0, err
@@ -573,28 +573,29 @@ func (dec *Decoder) decIgnoreOpFor(wireId typeId) (decOp, os.Error) {
        op, ok := decIgnoreOpMap[wireId]
        if !ok {
                // Special cases
-               switch t := wireId.gobType().(type) {
-               case *sliceType:
-                       elemId := wireId.gobType().(*sliceType).Elem
+               wire := dec.wireType[wireId]
+               switch {
+               case wire.array != nil:
+                       elemId := wire.array.Elem
                        elemOp, err := dec.decIgnoreOpFor(elemId)
                        if err != nil {
                                return nil, err
                        }
                        op = func(i *decInstr, state *decodeState, p unsafe.Pointer) {
-                               state.err = ignoreSlice(state, elemOp)
+                               state.err = ignoreArray(state, elemOp, wire.array.Len)
                        }
 
-               case *arrayType:
-                       elemId := wireId.gobType().(*arrayType).Elem
+               case wire.slice != nil:
+                       elemId := wire.slice.Elem
                        elemOp, err := dec.decIgnoreOpFor(elemId)
                        if err != nil {
                                return nil, err
                        }
                        op = func(i *decInstr, state *decodeState, p unsafe.Pointer) {
-                               state.err = ignoreArray(state, elemOp, t.Len)
+                               state.err = ignoreSlice(state, elemOp)
                        }
 
-               case *structType:
+               case wire.strct != nil:
                        // Generate a closure that calls out to the engine for the nested type.
                        enginePtr, err := dec.getIgnoreEnginePtr(wireId)
                        if err != nil {
@@ -660,8 +661,12 @@ func (dec *Decoder) compatibleType(fr reflect.Type, fw typeId) bool {
        case *reflect.StringType:
                return fw == tString
        case *reflect.ArrayType:
-               aw, ok := fw.gobType().(*arrayType)
-               return ok && t.Len() == aw.Len && dec.compatibleType(t.Elem(), aw.Elem)
+               wire, ok := dec.wireType[fw]
+               if !ok || wire.array == nil {
+                       return false
+               }
+               array := wire.array
+               return ok && t.Len() == array.Len && dec.compatibleType(t.Elem(), array.Elem)
        case *reflect.SliceType:
                // Is it an array of bytes?
                et := t.Elem()
@@ -714,8 +719,9 @@ func (dec *Decoder) compileDec(remoteId typeId, rt reflect.Type) (engine *decEng
                        continue
                }
                if !dec.compatibleType(localField.Type, wireField.id) {
-                       details := " (" + wireField.id.string() + " incompatible with " + localField.Type.String() + ") in type " + remoteId.Name()
-                       return nil, os.ErrorString("gob: wrong type for field " + wireField.name + details)
+                       return nil, os.ErrorString("gob: wrong type (" +
+                               localField.Type.String() + ") for received field " +
+                               wireStruct.name + "." + wireField.name)
                }
                op, indir, err := dec.decOpFor(wireField.id, localField.Type, localField.Name)
                if err != nil {
@@ -776,7 +782,7 @@ func (dec *Decoder) decode(wireId typeId, e interface{}) os.Error {
                return err
        }
        engine := *enginePtr
-       if engine.numInstr == 0 && st.NumField() > 0 && len(wireId.gobType().(*structType).field) > 0 {
+       if engine.numInstr == 0 && st.NumField() > 0 && len(dec.wireType[wireId].strct.field) > 0 {
                name := rt.Name()
                return os.ErrorString("gob: type mismatch: no fields matched compiling decoder for " + name)
        }