the first time a structure type appears when printing, identify it by name:

	type Foo struct { a int; next *Foo }
produces
	"Foo = struct { a int; next Foo }"

R=rsc
OCL=30797
CL=30820

diff --git a/src/pkg/gob/type.go b/src/pkg/gob/type.go
index 7bf06b0495681a303f3a9af16a8b52e63a65e8ee..35661027c1024cd0a92b5565052b139c99b4ef8b 100644 (file)
--- a/src/pkg/gob/type.go
+++ b/src/pkg/gob/type.go
@@ -8,7 +8,9 @@ import (
        "fmt";
        "os";
        "reflect";
+       "strings";
        "sync";
+       "unicode";
 )
 
 var id uint32  // incremented for each new type we build
@@ -119,7 +121,7 @@ func (s *structType) safeString(seen map[uint32] bool) string {
                return s.name
        }
        seen[s._id] = true;
-       str := "struct { ";
+       str := s.name + " = struct { ";
        for _, f := range s.field {
                str += fmt.Sprintf("%s %s; ", f.name, f.typ.safeString(seen));
        }
@@ -170,8 +172,15 @@ func newTypeObject(name string, rt reflect.Type) Type {
                st := rt.(reflect.StructType);
                field := make([]*fieldType, st.Len());
                for i := 0; i < st.Len(); i++ {
-                       name, typ, tag, offset := st.Field(i);
-                       field[i] =  &fieldType{ name, newType("", typ) };
+                       name, typ, _tag, _offset := st.Field(i);
+                       // Find trailing name in type, e.g. from "*gob.Bar" want "Bar", which
+                       // is defined as the word after the period (there is at most one period).
+                       typestring := typ.String();
+                       period := strings.Index(typestring, ".");
+                       if period >= 0 {
+                               typestring = typestring[period+1:len(typestring)]
+                       }
+                       field[i] =  &fieldType{ name, newType(typestring, typ) };
                }
                strType.field = field;
                return strType;

diff --git a/src/pkg/gob/type_test.go b/src/pkg/gob/type_test.go
index 462944395311c32c3ee20cd65942703ffee44122..9a615621f828ebf924c104240839680be06c71db 100644 (file)
--- a/src/pkg/gob/type_test.go
+++ b/src/pkg/gob/type_test.go
@@ -118,14 +118,15 @@ type Foo struct {
        d *float;       // will become float32
        e ****float64;  // will become float64
        f *Bar;
-       g *Foo; // will not explode
+       g *Bar; // should not interpolate the definition of Bar again
+       h *Foo; // will not explode
 }
 
 func TestStructType(t *testing.T) {
        sstruct := GetType("Foo", Foo{});
        str := sstruct.String();
        // If we can print it correctly, we built it correctly.
-       expected := "struct { a int; b int; c string; d float32; e float64; f struct { x string; }; g Foo; }";
+       expected := "Foo = struct { a int; b int; c string; d float32; e float64; f Bar = struct { x string; }; g Bar; h Foo; }";
        if str != expected {
                t.Errorf("struct printed as %q; expected %q", str, expected);
        }