bytes: rely on utf8.AppendRune

This is both simpler and more performant.

WriteRune                                 23.9µs ± 1%   22.8µs ± 8%   -4.43%  (p=0.006 n=8+10)
ToUpper/longɐstringɐwithɐnonasciiⱯchars    573ns ± 4%    474ns ± 6%  -17.27%  (p=0.000 n=10+10)
ToUpper/ɐɐɐɐɐ                              236ns ± 6%    202ns ± 5%  -14.12%  (p=0.000 n=10+10)
ToUpper/a\u0080\U0010ffff                 98.8ns ± 6%   91.2ns ± 3%   -7.67%  (p=0.000 n=10+10)
ToLower/LONGⱯSTRINGⱯWITHⱯNONASCIIⱯCHARS    511ns ± 3%    409ns ± 4%  -20.02%  (p=0.000 n=10+10)
ToLower/ⱭⱭⱭⱭⱭ                              178ns ± 4%    173ns ± 2%   -2.76%  (p=0.005 n=10+10)
ToLower/A\u0080\U0010ffff                  100ns ± 3%     91ns ± 2%   -8.55%  (p=0.000 n=10+10)

Change-Id: I968ef194da2c115cbdcac2d3575c34c65e6a8a56
Reviewed-on: https://go-review.googlesource.com/c/go/+/412337
Reviewed-by: Ian Lance Taylor <iant@google.com>
Auto-Submit: Joseph Tsai <joetsai@digital-static.net>
TryBot-Result: Gopher Robot <gobot@golang.org>
Reviewed-by: David Chase <drchase@google.com>
Run-TryBot: Joseph Tsai <joetsai@digital-static.net>

diff --git a/src/bytes/buffer.go b/src/bytes/buffer.go
index 0bacbda16490ed355c3420ced97cf39a222eecc8..ee83fd8b3620e5fd4ea33533b27c77cc2718930e 100644 (file)
--- a/src/bytes/buffer.go
+++ b/src/bytes/buffer.go
@@ -298,9 +298,8 @@ func (b *Buffer) WriteRune(r rune) (n int, err error) {
        if !ok {
                m = b.grow(utf8.UTFMax)
        }
-       n = utf8.EncodeRune(b.buf[m:m+utf8.UTFMax], r)
-       b.buf = b.buf[:m+n]
-       return n, nil
+       b.buf = utf8.AppendRune(b.buf[:m], r)
+       return len(b.buf) - m, nil
 }
 
 // Read reads the next len(p) bytes from the buffer or until the buffer

diff --git a/src/bytes/bytes.go b/src/bytes/bytes.go
index 5cf5b477ebdb13a5a1964d6cf1558fc1e0bf7198..7b28cf1efcd242d257513af9f7e2c865ebe2723a 100644 (file)
--- a/src/bytes/bytes.go
+++ b/src/bytes/bytes.go
@@ -560,9 +560,7 @@ func Map(mapping func(r rune) rune, s []byte) []byte {
        // In the worst case, the slice can grow when mapped, making
        // things unpleasant. But it's so rare we barge in assuming it's
        // fine. It could also shrink but that falls out naturally.
-       maxbytes := len(s) // length of b
-       nbytes := 0        // number of bytes encoded in b
-       b := make([]byte, maxbytes)
+       b := make([]byte, 0, len(s))
        for i := 0; i < len(s); {
                wid := 1
                r := rune(s[i])
@@ -571,22 +569,11 @@ func Map(mapping func(r rune) rune, s []byte) []byte {
                }
                r = mapping(r)
                if r >= 0 {
-                       rl := utf8.RuneLen(r)
-                       if rl < 0 {
-                               rl = len(string(utf8.RuneError))
-                       }
-                       if nbytes+rl > maxbytes {
-                               // Grow the buffer.
-                               maxbytes = maxbytes*2 + utf8.UTFMax
-                               nb := make([]byte, maxbytes)
-                               copy(nb, b[0:nbytes])
-                               b = nb
-                       }
-                       nbytes += utf8.EncodeRune(b[nbytes:maxbytes], r)
+                       b = utf8.AppendRune(b, r)
                }
                i += wid
        }
-       return b[0:nbytes]
+       return b
 }
 
 // Repeat returns a new byte slice consisting of count copies of b.