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 3566102..c7687b0 100644
--- a/src/pkg/gob/type.go
+++ b/src/pkg/gob/type.go
@@ -57,6 +57,7 @@
var tFloat32 Type
var tFloat64 Type
var tString Type
+var tBytes Type
// Array type
type arrayType struct {
@@ -157,9 +158,12 @@
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 @@
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 9a61562..a2efee9 100644
--- a/src/pkg/gob/type_test.go
+++ b/src/pkg/gob/type_test.go
@@ -30,6 +30,7 @@
typeT { tUint, "uint" },
typeT { tFloat32, "float32" },
typeT { tFloat64, "float64" },
+ typeT { tBytes, "bytes" },
typeT { tString, "string" },
}
@@ -115,18 +116,19 @@
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);
}
