add []byte as a special case: it will have a special, efficient encoding.

R=rsc
DELTA=16  (9 added, 1 deleted, 6 changed)
OCL=30846
CL=30846

diff --git a/src/pkg/gob/type.go b/src/pkg/gob/type.go
index 35661027c1024cd0a92b5565052b139c99b4ef8b..c7687b0c14c7b77815d2822796da8ad851cc5d9d 100644 (file)
--- a/src/pkg/gob/type.go
+++ b/src/pkg/gob/type.go
@@ -57,6 +57,7 @@ var tUint Type
 var tFloat32 Type
 var tFloat64 Type
 var tString Type
+var tBytes Type
 
 // Array type
 type arrayType struct {
@@ -157,9 +158,12 @@ func newTypeObject(name string, rt reflect.Type) Type {
        case reflect.StringKind:
                return tString
        case reflect.ArrayKind:
-               // TODO(r): worth a special case for array of bytes?
                at := rt.(reflect.ArrayType);
                if at.IsSlice() {
+                       // []byte == []uint8 is a special case
+                       if at.Elem().Kind() == reflect.Uint8Kind {
+                               return tBytes
+                       }
                        return newSliceType(name, newType("", at.Elem()));
                } else {
                        return newArrayType(name, newType("", at.Elem()), at.Len());
@@ -236,5 +240,7 @@ func init() {
        tUint = bootstrapType("uint", uint(0));
        tFloat32 = bootstrapType("float32", float32(0));
        tFloat64 = bootstrapType("float64", float64(0));
+       // The string for tBytes is "bytes" not "[]byte" to signify its specialness.
+       tBytes = bootstrapType("bytes", make([]byte, 0));
        tString= bootstrapType("string", "");
 }

diff --git a/src/pkg/gob/type_test.go b/src/pkg/gob/type_test.go
index 9a615621f828ebf924c104240839680be06c71db..a2efee9bac0e17d857896ea18e168d66efb9d21d 100644 (file)
--- a/src/pkg/gob/type_test.go
+++ b/src/pkg/gob/type_test.go
@@ -30,6 +30,7 @@ var basicTypes = []typeT {
        typeT { tUint, "uint" },
        typeT { tFloat32, "float32" },
        typeT { tFloat64, "float64" },
+       typeT { tBytes, "bytes" },
        typeT { tString, "string" },
 }
 
@@ -115,18 +116,19 @@ type Foo struct {
        a int;
        b int32;        // will become int
        c string;
-       d *float;       // will become float32
-       e ****float64;  // will become float64
-       f *Bar;
-       g *Bar; // should not interpolate the definition of Bar again
-       h *Foo; // will not explode
+       d []byte;
+       e *float;       // will become float32
+       f ****float64;  // will become float64
+       g *Bar;
+       h *Bar; // should not interpolate the definition of Bar again
+       i *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 := "Foo = struct { a int; b int; c string; d float32; e float64; f Bar = struct { x string; }; g Bar; h Foo; }";
+       expected := "Foo = struct { a int; b int; c string; d bytes; e float32; f float64; g Bar = struct { x string; }; h Bar; i Foo; }";
        if str != expected {
                t.Errorf("struct printed as %q; expected %q", str, expected);
        }