runtime: append([]byte, string...)

Fixes #2274

R=rsc, gri, dsymonds, bradfitz, lvd
CC=golang-dev
https://golang.org/cl/5149045

doc/go_spec.html

@@ -1,5 +1,5 @@
 <!-- title The Go Programming Language Specification -->
-<!-- subtitle Version of August 31, 2011 -->
+<!-- subtitle Version of September 29, 2011 -->
 
 <!--
 TODO
@@ -4658,6 +4658,10 @@ The values <code>x</code> are passed to a parameter of type <code>...T</code>
 where <code>T</code> is the <a href="#Slice_types">element type</a> of
 <code>S</code> and the respective
 <a href="#Passing_arguments_to_..._parameters">parameter passing rules</a> apply.
+As a special case, <code>append</code> also accepts a first argument
+assignable to type <code>[]byte</code> with a second argument of
+string type followed by <code>...</code>. This form appends the
+bytes of the string.
 </p>
 
 <pre class="grammar">
@@ -4679,6 +4683,9 @@ s3 := append(s2, s0...)    // append a slice              s3 == []int{0, 0, 2, 3
 
 var t []interface{}
 t = append(t, 42, 3.1415, "foo")                          t == []interface{}{42, 3.1415, "foo"}
+
+var b []byte
+b = append(b, "bar"...)    // append string contents      b == []byte{'b', 'a', 'r' }
 </pre>
 
 <p>

src/cmd/gc/builtin.c.boot

@@ -25,6 +25,7 @@ char *runtimeimport =
 	"func @\"\".concatstring ()\n"
 	"func @\"\".append ()\n"
 	"func @\"\".appendslice (typ *uint8, x any, y []any) any\n"
+	"func @\"\".appendstr (typ *uint8, x []uint8, y string) []uint8\n"
 	"func @\"\".cmpstring (? string, ? string) int\n"
 	"func @\"\".slicestring (? string, ? int, ? int) string\n"
 	"func @\"\".slicestring1 (? string, ? int) string\n"

src/cmd/gc/runtime.go

@@ -40,6 +40,7 @@ func concatstring()
 // filled in by compiler: Type*, int n, Slice, ...
 func append()
 func appendslice(typ *byte, x any, y []any) any
+func appendstr(typ *byte, x []byte, y string) []byte
 
 func cmpstring(string, string) int
 func slicestring(string, int, int) string

src/cmd/gc/typecheck.c

@@ -1008,6 +1008,10 @@ reswitch:
 				yyerror("too many arguments to append");
 				goto error;
 			}
+			if(istype(t->type, TUINT8) &&  istype(args->next->n->type, TSTRING)) {
+				defaultlit(&args->next->n, types[TSTRING]);
+				goto ret;
+			}
 			args->next->n = assignconv(args->next->n, t->orig, "append");
 			goto ret;
 		}

src/cmd/gc/walk.c

@@ -1056,8 +1056,12 @@ walkexpr(Node **np, NodeList **init)
 		goto ret;
 
 	case OAPPEND:
-		if(n->isddd)
+		if(n->isddd) {
+			if(istype(n->type->type, TUINT8) && istype(n->list->next->n->type, TSTRING))
+				n = mkcall("appendstr", n->type, init, typename(n->type), n->list->n, n->list->next->n);
+			else
 				n = appendslice(n, init);
+		}
 		else
 			n = append(n, init);
 		goto ret;

src/pkg/runtime/slice.c

@@ -11,7 +11,6 @@ static	int32	debug	= 0;
 
 static	void	makeslice1(SliceType*, int32, int32, Slice*);
 static	void	growslice1(SliceType*, Slice, int32, Slice *);
-static	void	appendslice1(SliceType*, Slice, Slice, Slice*);
 	void	runtime·slicecopy(Slice to, Slice fm, uintptr width, int32 ret);
 
 // see also unsafe·NewArray
@@ -52,12 +51,6 @@ makeslice1(SliceType *t, int32 len, int32 cap, Slice *ret)
 // appendslice(type *Type, x, y, []T) []T
 void
 runtime·appendslice(SliceType *t, Slice x, Slice y, Slice ret)
-{
-	appendslice1(t, x, y, &ret);
-}
-
-static void
-appendslice1(SliceType *t, Slice x, Slice y, Slice *ret)
 {
 	int32 m;
 	uintptr w;
@@ -68,15 +61,39 @@ appendslice1(SliceType *t, Slice x, Slice y, Slice *ret)
 		runtime·throw("append: slice overflow");
 
 	if(m > x.cap)
-		growslice1(t, x, m, ret);
+		growslice1(t, x, m, &ret);
 	else
-		*ret = x;
+		ret = x;
 
 	w = t->elem->size;
-	runtime·memmove(ret->array + ret->len*w, y.array, y.len*w);
+	runtime·memmove(ret.array + ret.len*w, y.array, y.len*w);
-	ret->len += y.len;
+	ret.len += y.len;
+	FLUSH(&ret);
 }
 
+
+// appendstr([]byte, string) []byte
+void
+runtime·appendstr(SliceType *t, Slice x, String y, Slice ret)
+{
+	int32 m;
+
+	m = x.len+y.len;
+
+	if(m < x.len)
+		runtime·throw("append: slice overflow");
+
+	if(m > x.cap)
+		growslice1(t, x, m, &ret);
+	else
+		ret = x;
+
+	runtime·memmove(ret.array + ret.len, y.str, y.len);
+	ret.len += y.len;
+	FLUSH(&ret);
+}
+
+
 // growslice(type *Type, x, []T, n int64) []T
 void
 runtime·growslice(SliceType *t, Slice old, int64 n, Slice ret)

test/append.go

@@ -63,6 +63,11 @@ var tests = []struct {
 	{"byte i", append([]byte{0, 1, 2}, []byte{3}...), []byte{0, 1, 2, 3}},
 	{"byte j", append([]byte{0, 1, 2}, []byte{3, 4, 5}...), []byte{0, 1, 2, 3, 4, 5}},
 
+	{"bytestr a", append([]byte{}, "0"...), []byte("0")},
+	{"bytestr b", append([]byte{}, "0123"...), []byte("0123")},
+
+	{"bytestr c", append([]byte("012"), "3"...), []byte("0123")},
+	{"bytestr d", append([]byte("012"), "345"...), []byte("012345")},
 
 	{"int16 a", append([]int16{}), []int16{}},
 	{"int16 b", append([]int16{}, 0), []int16{0}},