From 2b0837271056b9288cfcb8f57881325fa7f88da6 Mon Sep 17 00:00:00 2001
From: Rob Pike <r@golang.org>
Date: Mon, 29 Jun 2009 11:29:47 -0700
Subject: [PATCH] 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
---
 src/pkg/gob/type.go      |  8 +++++++-
 src/pkg/gob/type_test.go | 14 ++++++++------
 2 files changed, 15 insertions(+), 7 deletions(-)

diff --git a/src/pkg/gob/type.go b/src/pkg/gob/type.go
index 35661027c1..c7687b0c14 100644
--- 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 9a615621f8..a2efee9bac 100644
--- 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);
 	}
-- 
2.48.1