this repo has no description
all: use strings.Builder in a few more places
I was skimming the cue/errors source and noticed the opportunity,
and took a brief moment to look for others.
If all we need to do is build a string, this saves making one more copy.
Signed-off-by: Daniel Martí <mvdan@mvdan.cc>
Change-Id: Ife22d690c1357143bd044e65c571800eaeb273d2
Reviewed-on: https://review.gerrithub.io/c/cue-lang/cue/+/554519
Reviewed-by: Paul Jolly <paul@myitcv.io>
Unity-Result: CUE porcuepine <cue.porcuepine@gmail.com>
TryBot-Result: CUEcueckoo <cueckoo+gerrithub@cuelang.org>
+35
-35
+7
-7
cue/ast/astutil/resolve.go
+7
-7
cue/ast/astutil/resolve.go
···
17
17
package astutil
18
18
19
19
import (
20
-
"bytes"
21
20
"fmt"
21
+
"strings"
22
22
23
23
"cuelang.org/go/cue/ast"
24
24
"cuelang.org/go/cue/token"
···
447
447
448
448
// Debugging support
449
449
func (s *scope) String() string {
450
-
var buf bytes.Buffer
451
-
fmt.Fprintf(&buf, "scope %p {", s)
450
+
var b strings.Builder
451
+
fmt.Fprintf(&b, "scope %p {", s)
452
452
if s != nil && len(s.index) > 0 {
453
-
fmt.Fprintln(&buf)
453
+
fmt.Fprintln(&b)
454
454
for name := range s.index {
455
-
fmt.Fprintf(&buf, "\t%v\n", name)
455
+
fmt.Fprintf(&b, "\t%v\n", name)
456
456
}
457
457
}
458
-
fmt.Fprintf(&buf, "}\n")
459
-
return buf.String()
458
+
fmt.Fprintf(&b, "}\n")
459
+
return b.String()
460
460
}
+6
-7
cue/errors/errors.go
+6
-7
cue/errors/errors.go
···
20
20
package errors // import "cuelang.org/go/cue/errors"
21
21
22
22
import (
23
-
"bytes"
24
23
"errors"
25
24
"fmt"
26
25
"io"
···
569
568
// Details is a convenience wrapper for Print to return the error text as a
570
569
// string.
571
570
func Details(err error, cfg *Config) string {
572
-
w := &bytes.Buffer{}
573
-
Print(w, err, cfg)
574
-
return w.String()
571
+
var b strings.Builder
572
+
Print(&b, err, cfg)
573
+
return b.String()
575
574
}
576
575
577
576
// String generates a short message from a given Error.
578
577
func String(err Error) string {
579
-
w := &strings.Builder{}
580
-
writeErr(w, err)
581
-
return w.String()
578
+
var b strings.Builder
579
+
writeErr(&b, err)
580
+
return b.String()
582
581
}
583
582
584
583
func writeErr(w io.Writer, err Error) {
+4
-4
internal/str/str.go
+4
-4
internal/str/str.go
···
16
16
package str // import "cuelang.org/go/internal/str"
17
17
18
18
import (
19
-
"bytes"
20
19
"fmt"
20
+
"strings"
21
21
"unicode"
22
22
"unicode/utf8"
23
23
)
···
59
59
return s
60
60
61
61
Slow:
62
-
var buf bytes.Buffer
62
+
var b strings.Builder
63
63
for _, r := range s {
64
64
// SimpleFold(x) cycles to the next equivalent rune > x
65
65
// or wraps around to smaller values. Iterate until it wraps,
···
75
75
if 'A' <= r && r <= 'Z' {
76
76
r += 'a' - 'A'
77
77
}
78
-
buf.WriteRune(r)
78
+
b.WriteRune(r)
79
79
}
80
-
return buf.String()
80
+
return b.String()
81
81
}
82
82
83
83
// FoldDup reports a pair of strings from the list that are
+4
-4
pkg/encoding/csv/manual.go
+4
-4
pkg/encoding/csv/manual.go
···
15
15
package csv
16
16
17
17
import (
18
-
"bytes"
19
18
"encoding/csv"
20
19
"io"
20
+
"strings"
21
21
22
22
"cuelang.org/go/cue"
23
23
)
24
24
25
25
// Encode encode the given list of lists to CSV.
26
26
func Encode(x cue.Value) (string, error) {
27
-
buf := &bytes.Buffer{}
28
-
w := csv.NewWriter(buf)
27
+
var b strings.Builder
28
+
w := csv.NewWriter(&b)
29
29
iter, err := x.List()
30
30
if err != nil {
31
31
return "", err
···
51
51
_ = w.Write(a)
52
52
}
53
53
w.Flush()
54
-
return buf.String(), nil
54
+
return b.String(), nil
55
55
}
56
56
57
57
// Decode reads in a csv into a list of lists.
+6
-5
pkg/encoding/json/manual.go
+6
-5
pkg/encoding/json/manual.go
···
19
19
"encoding/json"
20
20
"fmt"
21
21
"io"
22
+
"strings"
22
23
23
24
"cuelang.org/go/cue"
24
25
"cuelang.org/go/cue/ast"
···
82
83
if err != nil {
83
84
return "", err
84
85
}
85
-
buf := &bytes.Buffer{}
86
+
var b strings.Builder
86
87
for iter.Next() {
87
-
b, err := internaljson.Marshal(iter.Value())
88
+
p, err := internaljson.Marshal(iter.Value())
88
89
if err != nil {
89
90
return "", err
90
91
}
91
-
buf.Write(b)
92
-
buf.WriteByte('\n')
92
+
b.Write(p)
93
+
b.WriteByte('\n')
93
94
}
94
-
return buf.String(), nil
95
+
return b.String(), nil
95
96
}
96
97
97
98
// UnmarshalStream parses the JSON to a CUE instance.
+4
-4
pkg/text/tabwriter/manual.go
+4
-4
pkg/text/tabwriter/manual.go
···
15
15
package tabwriter
16
16
17
17
import (
18
-
"bytes"
19
18
"fmt"
19
+
"strings"
20
20
"text/tabwriter"
21
21
22
22
"cuelang.org/go/cue"
···
25
25
// Write formats text in columns. See golang.org/pkg/text/tabwriter for more
26
26
// info.
27
27
func Write(data cue.Value) (string, error) {
28
-
buf := &bytes.Buffer{}
29
-
tw := tabwriter.NewWriter(buf, 0, 4, 1, ' ', 0)
28
+
var b strings.Builder
29
+
tw := tabwriter.NewWriter(&b, 0, 4, 1, ' ', 0)
30
30
31
31
write := func(v cue.Value) error {
32
32
b, err := v.Bytes()
···
57
57
}
58
58
59
59
err := tw.Flush()
60
-
return buf.String(), err
60
+
return b.String(), err
61
61
}
+4
-4
pkg/text/template/manual.go
+4
-4
pkg/text/template/manual.go
···
15
15
package template
16
16
17
17
import (
18
-
"bytes"
18
+
"strings"
19
19
"text/template"
20
20
21
21
"cuelang.org/go/cue"
···
31
31
if err := data.Decode(&x); err != nil {
32
32
return "", err
33
33
}
34
-
buf := &bytes.Buffer{}
35
-
if err := t.Execute(buf, x); err != nil {
34
+
var b strings.Builder
35
+
if err := t.Execute(&b, x); err != nil {
36
36
return "", err
37
37
}
38
-
return buf.String(), nil
38
+
return b.String(), nil
39
39
}