Also, consistently use declaration: var buf strings.Builder.
We don't change exported signatures to match go/types (where we
can't change the exported signatures for backward-compatibility).
Change-Id: I75350886aa231889ae2fd5c4008dd4be9ed6e09f
Reviewed-on: https://go-review.googlesource.com/c/go/+/428094
TryBot-Result: Gopher Robot <gobot@golang.org>
Run-TryBot: Robert Griesemer <gri@google.com>
Auto-Submit: Robert Griesemer <gri@google.com>
Reviewed-by: Ian Lance Taylor <iant@google.com>
Reviewed-by: Robert Griesemer <gri@google.com>
package types2
import (
- "bytes"
"cmd/compile/internal/syntax"
"fmt"
"go/constant"
+ "strings"
)
// An Error describes a type-checking error; it implements the error interface.
}
func (init *Initializer) String() string {
- var buf bytes.Buffer
+ var buf strings.Builder
for i, lhs := range init.Lhs {
if i > 0 {
buf.WriteString(", ")
package types2_test
import (
- "bytes"
"cmd/compile/internal/syntax"
"errors"
"fmt"
}
func predString(tv TypeAndValue) string {
- var buf bytes.Buffer
+ var buf strings.Builder
pred := func(b bool, s string) {
if b {
if buf.Len() > 0 {
package types2
import (
- "bytes"
"cmd/compile/internal/syntax"
"fmt"
"runtime"
if err.empty() {
return "no error"
}
- var buf bytes.Buffer
+ var buf strings.Builder
for i := range err.desc {
p := &err.desc[i]
if i > 0 {
case syntax.Expr:
arg = syntax.String(a)
case []syntax.Expr:
- var buf bytes.Buffer
+ var buf strings.Builder
buf.WriteByte('[')
for i, x := range a {
if i > 0 {
case Type:
arg = typeString(a, qf, debug)
case []Type:
- var buf bytes.Buffer
+ var buf strings.Builder
buf.WriteByte('[')
for i, x := range a {
if i > 0 {
buf.WriteByte(']')
arg = buf.String()
case []*TypeParam:
- var buf bytes.Buffer
+ var buf strings.Builder
buf.WriteByte('[')
for i, x := range a {
if i > 0 {
// stripAnnotations removes internal (type) annotations from s.
func stripAnnotations(s string) string {
- var b strings.Builder
+ var buf strings.Builder
for _, r := range s {
// strip #'s and subscript digits
if r < '₀' || '₀'+10 <= r { // '₀' == U+2080
- b.WriteRune(r)
+ buf.WriteRune(r)
}
}
- if b.Len() < len(s) {
- return b.String()
+ if buf.Len() < len(s) {
+ return buf.String()
}
return s
}
// from source, use golang.org/x/tools/go/loader.
import (
- "bytes"
"cmd/compile/internal/syntax"
"cmd/compile/internal/types2"
"fmt"
// Print the tree of scopes.
// For determinism, we redact addresses.
- var buf bytes.Buffer
+ var buf strings.Builder
pkg.Scope().WriteTo(&buf, 0, true)
rx := regexp.MustCompile(` 0x[a-fA-F0-9]*`)
fmt.Println(rx.ReplaceAllString(buf.String(), ""))
// fmt.Println("Types and Values of each expression:")
// items = nil
// for expr, tv := range info.Types {
- // var buf bytes.Buffer
+ // var buf strings.Builder
// posn := expr.Pos()
// tvstr := tv.Type.String()
// if tv.Value != nil {
}
// general case (n > 2)
- var b strings.Builder
+ var buf strings.Builder
for i, tname := range list[:n-1] {
if i > 0 {
- b.WriteString(", ")
+ buf.WriteString(", ")
}
- b.WriteString(tname.obj.name)
+ buf.WriteString(tname.obj.name)
}
- b.WriteString(", and ")
- b.WriteString(list[n-1].obj.name)
- return b.String()
+ buf.WriteString(", and ")
+ buf.WriteString(list[n-1].obj.name)
+ return buf.String()
}
// isParameterized reports whether typ contains any of the type parameters of tparams.
// Copied from errors.go.
func stripAnnotations(s string) string {
- var b strings.Builder
+ var buf strings.Builder
for _, r := range s {
// strip #'s and subscript digits
if r < '₀' || '₀'+10 <= r { // '₀' == U+2080
- b.WriteRune(r)
+ buf.WriteRune(r)
}
}
- if b.Len() < len(s) {
- return b.String()
+ if buf.Len() < len(s) {
+ return buf.String()
}
return s
}
package types2_test
import (
- "bytes"
"cmd/compile/internal/syntax"
"fmt"
"internal/testenv"
// printInfo prints the *Func definitions recorded in info, one *Func per line.
printInfo := func(info *Info) string {
- var buf bytes.Buffer
+ var buf strings.Builder
for _, obj := range info.Defs {
if fn, ok := obj.(*Func); ok {
fmt.Fprintln(&buf, fn)
package types2_test
import (
- "bytes"
"cmd/compile/internal/syntax"
"cmd/compile/internal/types2"
"errors"
}
files := []*syntax.File{file}
- var buf bytes.Buffer
+ var buf strings.Builder
conf := types2.Config{
Error: func(err error) { fmt.Fprintln(&buf, err) },
Importer: defaultImporter(),
package types2
import (
- "bytes"
"cmd/compile/internal/syntax"
"fmt"
"io"
// String returns a string representation of the scope, for debugging.
func (s *Scope) String() string {
- var buf bytes.Buffer
+ var buf strings.Builder
s.WriteTo(&buf, 0, false)
return buf.String()
}
package types2
-import "bytes"
+import "strings"
// A termlist represents the type set represented by the union
// t1 ∪ y2 ∪ ... tn of the type sets of the terms t1 to tn.
if len(xl) == 0 {
return "∅"
}
- var buf bytes.Buffer
+ var buf strings.Builder
for i, x := range xl {
if i > 0 {
buf.WriteString(termSep)
package types2
import (
- "bytes"
"cmd/compile/internal/syntax"
"fmt"
"sort"
+ "strings"
)
// ----------------------------------------------------------------------------
hasMethods := len(s.methods) > 0
hasTerms := s.hasTerms()
- var buf bytes.Buffer
+ var buf strings.Builder
buf.WriteByte('{')
if s.comparable {
buf.WriteString("comparable")
package types_test
import (
- "bytes"
"errors"
"fmt"
"go/ast"
}
func predString(tv TypeAndValue) string {
- var buf bytes.Buffer
+ var buf strings.Builder
pred := func(b bool, s string) {
if b {
if buf.Len() > 0 {
if err.empty() {
return "no error"
}
- var buf bytes.Buffer
+ var buf strings.Builder
for i := range err.desc {
p := &err.desc[i]
if i > 0 {
case Type:
arg = typeString(a, qf, debug)
case []Type:
- var buf bytes.Buffer
+ var buf strings.Builder
buf.WriteByte('[')
for i, x := range a {
if i > 0 {
buf.WriteByte(']')
arg = buf.String()
case []*TypeParam:
- var buf bytes.Buffer
+ var buf strings.Builder
buf.WriteByte('[')
for i, x := range a {
if i > 0 {
// stripAnnotations removes internal (type) annotations from s.
func stripAnnotations(s string) string {
- var b strings.Builder
+ var buf strings.Builder
for _, r := range s {
// strip #'s and subscript digits
if r < '₀' || '₀'+10 <= r { // '₀' == U+2080
- b.WriteRune(r)
+ buf.WriteRune(r)
}
}
- if b.Len() < len(s) {
- return b.String()
+ if buf.Len() < len(s) {
+ return buf.String()
}
return s
}
// from source, use golang.org/x/tools/go/loader.
import (
- "bytes"
"fmt"
"go/ast"
"go/format"
// Print the tree of scopes.
// For determinism, we redact addresses.
- var buf bytes.Buffer
+ var buf strings.Builder
pkg.Scope().WriteTo(&buf, 0, true)
rx := regexp.MustCompile(` 0x[a-fA-F0-9]*`)
fmt.Println(rx.ReplaceAllString(buf.String(), ""))
fmt.Println("Types and Values of each expression:")
items = nil
for expr, tv := range info.Types {
- var buf bytes.Buffer
+ var buf strings.Builder
posn := fset.Position(expr.Pos())
tvstr := tv.Type.String()
if tv.Value != nil {
}
func exprString(fset *token.FileSet, expr ast.Expr) string {
- var buf bytes.Buffer
+ var buf strings.Builder
format.Node(&buf, fset, expr)
return buf.String()
}
}
// general case (n > 2)
- var b strings.Builder
+ var buf strings.Builder
for i, tname := range list[:n-1] {
if i > 0 {
- b.WriteString(", ")
+ buf.WriteString(", ")
}
- b.WriteString(tname.obj.name)
+ buf.WriteString(tname.obj.name)
}
- b.WriteString(", and ")
- b.WriteString(list[n-1].obj.name)
- return b.String()
+ buf.WriteString(", and ")
+ buf.WriteString(list[n-1].obj.name)
+ return buf.String()
}
// isParameterized reports whether typ contains any of the type parameters of tparams.
// Copied from errors.go.
func stripAnnotations(s string) string {
- var b strings.Builder
+ var buf strings.Builder
for _, r := range s {
// strip #'s and subscript digits
if r < '₀' || '₀'+10 <= r { // '₀' == U+2080
- b.WriteRune(r)
+ buf.WriteRune(r)
}
}
- if b.Len() < len(s) {
- return b.String()
+ if buf.Len() < len(s) {
+ return buf.String()
}
return s
}
package types_test
import (
- "bytes"
"fmt"
"go/ast"
"go/importer"
// printInfo prints the *Func definitions recorded in info, one *Func per line.
printInfo := func(info *Info) string {
- var buf bytes.Buffer
+ var buf strings.Builder
for _, obj := range info.Defs {
if fn, ok := obj.(*Func); ok {
fmt.Fprintln(&buf, fn)
package types_test
import (
- "bytes"
"errors"
"fmt"
"go/ast"
}
files := []*ast.File{file}
- var buf bytes.Buffer
+ var buf strings.Builder
conf := types.Config{
Error: func(err error) { fmt.Fprintln(&buf, err) },
Importer: importer.Default(),
package types
import (
- "bytes"
"fmt"
"go/token"
"io"
// String returns a string representation of the scope, for debugging.
func (s *Scope) String() string {
- var buf bytes.Buffer
+ var buf strings.Builder
s.WriteTo(&buf, 0, false)
return buf.String()
}
package types
-import "bytes"
+import "strings"
// A termlist represents the type set represented by the union
// t1 ∪ y2 ∪ ... tn of the type sets of the terms t1 to tn.
if len(xl) == 0 {
return "∅"
}
- var buf bytes.Buffer
+ var buf strings.Builder
for i, x := range xl {
if i > 0 {
buf.WriteString(termSep)
package types
import (
- "bytes"
"fmt"
"go/token"
"sort"
+ "strings"
)
// ----------------------------------------------------------------------------
hasMethods := len(s.methods) > 0
hasTerms := s.hasTerms()
- var buf bytes.Buffer
+ var buf strings.Builder
buf.WriteByte('{')
if s.comparable {
buf.WriteString("comparable")