strconv: move all but Quote to internal/strconv

This will let low-level things depend on the canonical routines,
even for floating-point printing.

Change-Id: I31207dc6584ad90d4e365dbe6eaf20f8662ed22d
Reviewed-on: https://go-review.googlesource.com/c/go/+/716000
Reviewed-by: David Chase <drchase@google.com>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>

Author: rsc

src/go/build/deps_test.go

@@ -69,6 +69,7 @@ var depsRules = `
 
 	internal/goarch < internal/abi;
 	internal/byteorder, internal/cpu, internal/goarch < internal/chacha8rand;
+	internal/goarch, math/bits < internal/strconv;
 
 	# RUNTIME is the core runtime group of packages, all of them very light-weight.
 	internal/abi,
@@ -80,6 +81,7 @@ var depsRules = `
 	internal/goexperiment,
 	internal/goos,
 	internal/profilerecord,
+	internal/strconv,
 	internal/trace/tracev2,
 	math/bits,
 	structs

src/strconv/atob.go renamed to src/internal/strconv/atob.go

@@ -14,7 +14,7 @@ func ParseBool(str string) (bool, error) {
 	case "0", "f", "F", "false", "FALSE", "False":
 		return false, nil
 	}
-	return false, syntaxError("ParseBool", str)
+	return false, ErrSyntax
 }
 
 // FormatBool returns "true" or "false" according to the value of b.

src/strconv/atob_test.go renamed to src/internal/strconv/atob_test.go

@@ -6,7 +6,7 @@ package strconv_test
 
 import (
 	"bytes"
-	. "strconv"
+	. "internal/strconv"
 	"testing"
 )
 
@@ -36,23 +36,8 @@ var atobtests = []atobTest{
 func TestParseBool(t *testing.T) {
 	for _, test := range atobtests {
 		b, e := ParseBool(test.in)
-		if test.err != nil {
-			// expect an error
-			if e == nil {
-				t.Errorf("ParseBool(%s) = nil; want %s", test.in, test.err)
-			} else {
-				// NumError assertion must succeed; it's the only thing we return.
-				if e.(*NumError).Err != test.err {
-					t.Errorf("ParseBool(%s) = %s; want %s", test.in, e, test.err)
-				}
-			}
-		} else {
-			if e != nil {
-				t.Errorf("ParseBool(%s) = %s; want nil", test.in, e)
-			}
-			if b != test.out {
-				t.Errorf("ParseBool(%s) = %t; want %t", test.in, b, test.out)
-			}
+		if b != test.out || e != test.err {
+			t.Errorf("ParseBool(%s) = %v, %v, want %v, %v", test.in, b, e, test.out, test.err)
 		}
 	}
 }

src/strconv/atoc.go renamed to src/internal/strconv/atoc.go

@@ -4,23 +4,6 @@
 
 package strconv
 
-import "internal/stringslite"
-
-const fnParseComplex = "ParseComplex"
-
-// convErr splits an error returned by parseFloatPrefix
-// into a syntax or range error for ParseComplex.
-func convErr(err error, s string) (syntax, range_ error) {
-	if x, ok := err.(*NumError); ok {
-		x.Func = fnParseComplex
-		x.Num = stringslite.Clone(s)
-		if x.Err == ErrRange {
-			return nil, x
-		}
-	}
-	return err, nil
-}
-
 // ParseComplex converts the string s to a complex number
 // with the precision specified by bitSize: 64 for complex64, or 128 for complex128.
 // When bitSize=64, the result still has type complex128, but it will be
@@ -47,8 +30,6 @@ func ParseComplex(s string, bitSize int) (complex128, error) {
 		size = 32 // complex64 uses float32 parts
 	}
 
-	orig := s
-
 	// Remove parentheses, if any.
 	if len(s) >= 2 && s[0] == '(' && s[len(s)-1] == ')' {
 		s = s[1 : len(s)-1]
@@ -59,10 +40,10 @@ func ParseComplex(s string, bitSize int) (complex128, error) {
 	// Read real part (possibly imaginary part if followed by 'i').
 	re, n, err := parseFloatPrefix(s, size)
 	if err != nil {
-		err, pending = convErr(err, orig)
-		if err != nil {
+		if err != ErrRange {
 			return 0, err
 		}
+		pending = err
 	}
 	s = s[n:]
 
@@ -88,20 +69,20 @@ func ParseComplex(s string, bitSize int) (complex128, error) {
 		}
 		fallthrough
 	default:
-		return 0, syntaxError(fnParseComplex, orig)
+		return 0, ErrSyntax
 	}
 
 	// Read imaginary part.
 	im, n, err := parseFloatPrefix(s, size)
 	if err != nil {
-		err, pending = convErr(err, orig)
-		if err != nil {
+		if err != ErrRange {
 			return 0, err
 		}
+		pending = err
 	}
 	s = s[n:]
 	if s != "i" {
-		return 0, syntaxError(fnParseComplex, orig)
+		return 0, ErrSyntax
 	}
 	return complex(re, im), pending
 }

src/strconv/atoc_test.go renamed to src/internal/strconv/atoc_test.go

@@ -7,8 +7,7 @@ package strconv_test
 import (
 	"math"
 	"math/cmplx"
-	"reflect"
-	. "strconv"
+	. "internal/strconv"
 	"testing"
 )
 
@@ -188,30 +187,24 @@ func TestParseComplex(t *testing.T) {
 	}
 	for i := range tests {
 		test := &tests[i]
-		if test.err != nil {
-			test.err = &NumError{Func: "ParseComplex", Num: test.in, Err: test.err}
+		c, e := ParseComplex(test.in, 128)
+		if !sameComplex(c, test.out) || e != test.err {
+			t.Errorf("ParseComplex(%s, 128) = %v, %v, want %v, %v", test.in, c, e, test.out, test.err)
 		}
-		got, err := ParseComplex(test.in, 128)
-		if !reflect.DeepEqual(err, test.err) {
-			t.Fatalf("ParseComplex(%q, 128) = %v, %v; want %v, %v", test.in, got, err, test.out, test.err)
-		}
-		if !(cmplx.IsNaN(test.out) && cmplx.IsNaN(got)) && got != test.out {
-			t.Fatalf("ParseComplex(%q, 128) = %v, %v; want %v, %v", test.in, got, err, test.out, test.err)
-		}
-
 		if complex128(complex64(test.out)) == test.out {
-			got, err := ParseComplex(test.in, 64)
-			if !reflect.DeepEqual(err, test.err) {
-				t.Fatalf("ParseComplex(%q, 64) = %v, %v; want %v, %v", test.in, got, err, test.out, test.err)
-			}
-			got64 := complex64(got)
-			if complex128(got64) != test.out {
-				t.Fatalf("ParseComplex(%q, 64) = %v, %v; want %v, %v", test.in, got, err, test.out, test.err)
+			c, e := ParseComplex(test.in, 64)
+			c64 := complex64(c)
+			if !sameComplex(complex128(c64) , test.out) || e != test.err {
+				t.Errorf("ParseComplex(%s, 64) = %v, %v, want %v, %v", test.in, c, e, test.out, test.err)
 			}
 		}
 	}
 }
 
+func sameComplex(c1, c2 complex128) bool {
+	return cmplx.IsNaN(c1) && cmplx.IsNaN(c2) || c1 == c2
+}
+
 // Issue 42297: allow ParseComplex(s, not_32_or_64) for legacy reasons
 func TestParseComplexIncorrectBitSize(t *testing.T) {
 	const s = "1.5e308+1.0e307i"

src/strconv/atof.go renamed to src/internal/strconv/atof.go

@@ -10,8 +10,6 @@ package strconv
 //   2) Multiply/divide decimal by powers of two until in range [0.5, 1)
 //   3) Multiply by 2^precision and round to get mantissa.
 
-import "math"
-
 var optimize = true // set to false to force slow-path conversions for testing
 
 // commonPrefixLenIgnoreCase returns the length of the common
@@ -58,11 +56,11 @@ func special(s string) (f float64, n int, ok bool) {
 			n = 3
 		}
 		if n == 3 || n == 8 {
-			return math.Inf(sign), nsign + n, true
+			return inf(sign), nsign + n, true
 		}
 	case 'n', 'N':
 		if commonPrefixLenIgnoreCase(s, "nan") == 3 {
-			return math.NaN(), 3, true
+			return nan(), 3, true
 		}
 	}
 	return 0, 0, false
@@ -546,7 +544,7 @@ func atofHex(s string, flt *floatInfo, mantissa uint64, exp int, neg, trunc bool
 	if exp > maxExp { // infinity and range error
 		mantissa = 1 << flt.mantbits
 		exp = maxExp + 1
-		err = rangeError(fnParseFloat, s)
+		err = ErrRange
 	}
 
 	bits := mantissa & (1<<flt.mantbits - 1)
@@ -555,9 +553,9 @@ func atofHex(s string, flt *floatInfo, mantissa uint64, exp int, neg, trunc bool
 		bits |= 1 << flt.mantbits << flt.expbits
 	}
 	if flt == &float32info {
-		return float64(math.Float32frombits(uint32(bits))), err
+		return float64(float32frombits(uint32(bits))), err
 	}
-	return math.Float64frombits(bits), err
+	return float64frombits(bits), err
 }
 
 const fnParseFloat = "ParseFloat"
@@ -569,7 +567,7 @@ func atof32(s string) (f float32, n int, err error) {
 
 	mantissa, exp, neg, trunc, hex, n, ok := readFloat(s)
 	if !ok {
-		return 0, n, syntaxError(fnParseFloat, s)
+		return 0, n, ErrSyntax
 	}
 
 	if hex {
@@ -603,12 +601,12 @@ func atof32(s string) (f float32, n int, err error) {
 	// Slow fallback.
 	var d decimal
 	if !d.set(s[:n]) {
-		return 0, n, syntaxError(fnParseFloat, s)
+		return 0, n, ErrSyntax
 	}
 	b, ovf := d.floatBits(&float32info)
-	f = math.Float32frombits(uint32(b))
+	f = float32frombits(uint32(b))
 	if ovf {
-		err = rangeError(fnParseFloat, s)
+		err = ErrRange
 	}
 	return f, n, err
 }
@@ -620,7 +618,7 @@ func atof64(s string) (f float64, n int, err error) {
 
 	mantissa, exp, neg, trunc, hex, n, ok := readFloat(s)
 	if !ok {
-		return 0, n, syntaxError(fnParseFloat, s)
+		return 0, n, ErrSyntax
 	}
 
 	if hex {
@@ -654,12 +652,12 @@ func atof64(s string) (f float64, n int, err error) {
 	// Slow fallback.
 	var d decimal
 	if !d.set(s[:n]) {
-		return 0, n, syntaxError(fnParseFloat, s)
+		return 0, n, ErrSyntax
 	}
 	b, ovf := d.floatBits(&float64info)
-	f = math.Float64frombits(b)
+	f = float64frombits(b)
 	if ovf {
-		err = rangeError(fnParseFloat, s)
+		err = ErrRange
 	}
 	return f, n, err
 }
@@ -693,8 +691,8 @@ func atof64(s string) (f float64, n int, err error) {
 // [floating-point literals]: https://go.dev/ref/spec#Floating-point_literals
 func ParseFloat(s string, bitSize int) (float64, error) {
 	f, n, err := parseFloatPrefix(s, bitSize)
-	if n != len(s) && (err == nil || err.(*NumError).Err != ErrSyntax) {
-		return 0, syntaxError(fnParseFloat, s)
+	if n != len(s) {
+		return 0, ErrSyntax
 	}
 	return f, err
 }

src/strconv/atof_test.go renamed to src/internal/strconv/atof_test.go

@@ -8,7 +8,7 @@ import (
 	"math"
 	"math/rand"
 	"reflect"
-	. "strconv"
+	. "internal/strconv"
 	"strings"
 	"sync"
 	"testing"
@@ -446,21 +446,6 @@ func initAtof() {
 }
 
 func initAtofOnce() {
-	// The atof routines return NumErrors wrapping
-	// the error and the string. Convert the table above.
-	for i := range atoftests {
-		test := &atoftests[i]
-		if test.err != nil {
-			test.err = &NumError{"ParseFloat", test.in, test.err}
-		}
-	}
-	for i := range atof32tests {
-		test := &atof32tests[i]
-		if test.err != nil {
-			test.err = &NumError{"ParseFloat", test.in, test.err}
-		}
-	}
-
 	// Generate random inputs for tests and benchmarks
 	if testing.Short() {
 		atofRandomTests = make([]atofSimpleTest, 100)
@@ -497,7 +482,7 @@ func TestParseFloatPrefix(t *testing.T) {
 		// correctly as "inf" with suffix.
 		for _, suffix := range []string{" ", "q", "+", "-", "<", "=", ">", "(", ")", "i", "init"} {
 			in := test.in + suffix
-			_, n, err := ParseFloatPrefix(in, 64)
+			_, n, err := parseFloatPrefix(in, 64)
 			if err != nil {
 				t.Errorf("ParseFloatPrefix(%q, 64): err = %v; want no error", in, err)
 			}

src/strconv/eisel_lemire.go renamed to src/internal/strconv/atofeisel.go

@@ -18,7 +18,6 @@ package strconv
 // https://github.com/nigeltao/parse-number-fxx-test-data/blob/5280dcfccf6d0b02a65ae282dad0b6d9de50e039/script/test-go-strconv.go
 
 import (
-	"math"
 	"math/bits"
 )
 
@@ -29,7 +28,7 @@ func eiselLemire64(man uint64, exp10 int, neg bool) (f float64, ok bool) {
 	// Exp10 Range.
 	if man == 0 {
 		if neg {
-			f = math.Float64frombits(0x8000000000000000) // Negative zero.
+			f = float64frombits(0x8000000000000000) // Negative zero.
 		}
 		return f, true
 	}
@@ -88,7 +87,7 @@ func eiselLemire64(man uint64, exp10 int, neg bool) (f float64, ok bool) {
 	if neg {
 		retBits |= 0x8000000000000000
 	}
-	return math.Float64frombits(retBits), true
+	return float64frombits(retBits), true
 }
 
 func eiselLemire32(man uint64, exp10 int, neg bool) (f float32, ok bool) {
@@ -104,7 +103,7 @@ func eiselLemire32(man uint64, exp10 int, neg bool) (f float32, ok bool) {
 	// Exp10 Range.
 	if man == 0 {
 		if neg {
-			f = math.Float32frombits(0x80000000) // Negative zero.
+			f = float32frombits(0x80000000) // Negative zero.
 		}
 		return f, true
 	}
@@ -163,5 +162,5 @@ func eiselLemire32(man uint64, exp10 int, neg bool) (f float32, ok bool) {
 	if neg {
 		retBits |= 0x80000000
 	}
-	return math.Float32frombits(uint32(retBits)), true
+	return float32frombits(uint32(retBits)), true
 }