pkg/strconv: add ParseNumber builtin

Expose literal.ParseNum via pkg/strconv so CUE code can parse native
number literals through the standard library. The wrapper returns an
internal.Decimal and surfaces syntax issues as *strconv.NumError,
matching the existing ParseInt/ParseFloat helpers.

The main use case here is being able to parse CUE number strings
such as 1Ki, which are not accepted by strconv.ParseInt.
Moreover, this API accepts both integer and floating point numbers,
so it's a superset of both strconv's ParseInt and ParseFloat.

We choose to name the built-in ParseNumber rather than ParseNum
given that this directly reflects the "number" predeclared identifier
in the CUE spec, so it's best to not shorten that name.

Closes #4139 as merged as of commit ac7daa6.

Signed-off-by: Carlos Jorge <[email protected]>
Change-Id: I1ed97630a24300884588bfdda0130fe40a7e7e2b
Reviewed-on: https://cue.gerrithub.io/c/cue-lang/cue/+/1226125
Reviewed-by: Marcel van Lohuizen <[email protected]>
Unity-Result: CUE porcuepine <[email protected]>
TryBot-Result: CUEcueckoo <[email protected]>

Author: cjorge-graphops

pkg/strconv/pkg.go

@@ -21,6 +21,8 @@
 package strconv
 
 import (
+	"cuelang.org/go/cue/literal"
+	"cuelang.org/go/internal"
 	"math/big"
 	"strconv"
 )
@@ -65,6 +67,36 @@ func ParseFloat(s string, bitSize int) (float64, error) {
 	return strconv.ParseFloat(s, bitSize)
 }
 
+// ParseNumber interprets s using the full CUE number literal syntax and returns
+// the resulting value as an arbitrary-precision decimal. It accepts decimal
+// and non-decimal bases, underscores as separators, fractional syntax, and
+// the decimal or binary multiplier suffixes defined by CUE (for example "1Ki"
+// and "10M").
+//
+// If s is not syntactically well-formed, ParseNumber returns a *strconv.NumError
+// with Err containing detailed syntax information. Semantic errors, such as a
+// multiplier that cannot be represented, are reported in the same way.
+func ParseNumber(s string) (*internal.Decimal, error) {
+	var info literal.NumInfo
+	if err := literal.ParseNum(s, &info); err != nil {
+		return nil, &strconv.NumError{
+			Func: "ParseNumber",
+			Num:  s,
+			Err:  err,
+		}
+	}
+
+	var dec internal.Decimal
+	if err := info.Decimal(&dec); err != nil {
+		return nil, &strconv.NumError{
+			Func: "ParseNumber",
+			Num:  s,
+			Err:  err,
+		}
+	}
+	return &dec, nil
+}
+
 // IntSize is the size in bits of an int or uint value.
 const IntSize = 64
 

pkg/strconv/strconv.go

@@ -53,6 +53,13 @@ t44: strconv.ParseUint("100", 16, 8)      // hex overflow uint8
 t45: strconv.ParseUint("invalid", 10, 8)  // syntax error
 t46: strconv.ParseUint("123", 10, -1)     // negative bitSize error
 t47: strconv.ParseUint("-1", 10, 8)       // negative value error
+// Test ParseNumber
+t48: strconv.ParseNumber("123.456")
+t49: strconv.ParseNumber("0xFF")
+t50: strconv.ParseNumber("1Ki")
+t51: strconv.ParseNumber("-.5")
+t52: strconv.ParseNumber("1_")
+t53: strconv.ParseNumber("0xG")
 -- out/strconv-v3 --
 Errors:
 t2: int 300 overflows byte in argument 1 in call to strconv.FormatFloat:
@@ -98,6 +105,10 @@ t46: error in call to strconv.ParseUint: strconv.ParseUint: parsing "123": value
     ./in.cue:51:6
 t47: error in call to strconv.ParseUint: strconv.ParseUint: parsing "-1": value out of range:
     ./in.cue:52:6
+t52: error in call to strconv.ParseNumber: strconv.ParseNumber: parsing "1_": illegal '_' in number:
+    ./in.cue:58:6
+t53: error in call to strconv.ParseNumber: strconv.ParseNumber: parsing "0xG": illegal hexadecimal number "0xG":
+    ./in.cue:59:6
 
 Result:
 t1:  "40"
@@ -150,6 +161,13 @@ t44: _|_ // t44: error in call to strconv.ParseUint: strconv.ParseUint: parsing
 t45: _|_ // t45: error in call to strconv.ParseUint: strconv.ParseUint: parsing "invalid": invalid syntax
 t46: _|_ // t46: error in call to strconv.ParseUint: strconv.ParseUint: parsing "123": value out of range
 t47: _|_ // t47: error in call to strconv.ParseUint: strconv.ParseUint: parsing "-1": value out of range
+// Test ParseNumber
+t48: 123.456
+t49: 255
+t50: 1024
+t51: -0.5
+t52: _|_ // t52: error in call to strconv.ParseNumber: strconv.ParseNumber: parsing "1_": illegal '_' in number
+t53: _|_ // t53: error in call to strconv.ParseNumber: strconv.ParseNumber: parsing "0xG": illegal hexadecimal number "0xG"
 -- diff/-out/strconv-v3<==>+out/strconv --
 diff old new
 --- old