Load each spelling that only restated a shorter one, as that shorter form

internal/builtinfunc/builtinfunc.go

@@ -28,8 +28,6 @@ type builtin struct {
 	// operands names the fields the call reads, which a render reads for it; nil
 	// for a builtin that reads none.
 	operands func(args []string) []string
-	// noRefOperands says no operand can be a reference.
-	noRefOperands bool
 	// proveNumber bounds the number a call's text reads as, token its body, and says which
 	// datatypes that text is not; set it where every render reads as a finite number, which
 	// makes the call a calc operand, and leave it nil otherwise.
@@ -79,9 +77,6 @@ func Operands(name string, args []string) []string {
 	return b.operands(args)
 }
 
-// NoRefOperands reports a builtin no operand of which can be a reference.
-func NoRefOperands(name string) bool { return builtins[name].noRefOperands }
-
 // IsTransform reports a builtin that rewrites the text of its one operand.
 func IsTransform(name string) bool {
 	_, isTransform := transforms[name]

internal/builtinfunc/builtinfunc_test.go

@@ -2,11 +2,9 @@ package builtinfunc
 
 import (
 	"fmt"
-	"slices"
 	"strings"
 	"testing"
 
-	"github.com/larvit/fejkdata/internal/grammar"
 	"github.com/larvit/fejkdata/internal/invariant"
 )
 
@@ -23,17 +21,6 @@ func TestRegistryShapes(t *testing.T) {
 	}
 }
 
-func TestNoRefOperandsMatchesTheOperandGrammar(t *testing.T) {
-	for name, b := range builtins {
-		if b.operands == nil {
-			continue
-		}
-		if takesRef := slices.ContainsFunc(b.operands([]string{"/x"}), grammar.IsRef); b.noRefOperands == takesRef {
-			t.Errorf("%s: noRefOperands = %v, yet a reference /x read as an operand: %v", name, b.noRefOperands, takesRef)
-		}
-	}
-}
-
 func TestCheckNamesWhatACallGetsWrong(t *testing.T) {
 	for _, c := range []struct {
 		name string

internal/builtinfunc/builtins.go

@@ -66,7 +66,7 @@ var builtins = withTransforms(map[string]builtin{
 	}},
 	"date":   {arity: -1, checkArgs: dateArgs, prep: datePrep},
 	"time":   {arity: -1, checkArgs: timeArg, prep: timePrep},
-	CalcName: {arity: -1, checkArgs: checkCalc, prep: calcPrep, operands: calcOperands, noRefOperands: true},
+	CalcName: {arity: -1, checkArgs: checkCalc, prep: calcPrep, operands: calcOperands},
 	// seq is the one stateful builtin: a per-generator counter from 1, advancing on
 	// each call. An optional name selects an independent counter; no name uses the
 	// default one. Deterministic by construction, so seeded output stays stable.
@@ -148,8 +148,7 @@ func randChars(r rng, n int, alphabet string) string {
 	return string(b)
 }
 
-// plainInt parses an integer arg written the one way: no sign, no leading zero.
-func plainInt(s string) (int, error) {
+func intArg(s string) (int, error) {
 	n, err := strconv.Atoi(s)
 	if errors.Is(err, strconv.ErrRange) {
 		return 0, fmt.Errorf("%q is past the integer range: %w", s, err)
@@ -157,13 +156,10 @@ func plainInt(s string) (int, error) {
 	if err != nil {
 		return 0, fmt.Errorf("%q is not an integer", s)
 	}
-	if strconv.Itoa(n) != s {
-		return 0, fmt.Errorf("%q is not a plain integer; write %d", s, n)
-	}
 	return n, nil
 }
 func posIntArg(a []string) error {
-	n, err := plainInt(a[0])
+	n, err := intArg(a[0])
 	if errors.Is(err, strconv.ErrRange) {
 		return fmt.Errorf("count %q exceeds the maximum %d", a[0], maxLen)
 	}
@@ -179,11 +175,11 @@ func posIntArg(a []string) error {
 	return nil
 }
 func intRangeArgs(a []string) error {
-	lo, err := plainInt(a[0])
+	lo, err := intArg(a[0])
 	if err != nil {
 		return fmt.Errorf("int(min,max): min %w", err)
 	}
-	hi, err := plainInt(a[1])
+	hi, err := intArg(a[1])
 	if err != nil {
 		return fmt.Errorf("int(min,max): max %w", err)
 	}
@@ -204,7 +200,7 @@ func floatArgs(a []string) error {
 	if e1 != nil || e2 != nil {
 		return fmt.Errorf("float(min,max,dp) needs numeric bounds, got %q,%q", a[0], a[1])
 	}
-	dp, err := plainInt(a[2])
+	dp, err := intArg(a[2])
 	if err != nil {
 		return fmt.Errorf("float(min,max,dp): decimals %w", err)
 	}

internal/builtinfunc/calc.go

@@ -56,7 +56,7 @@ func checkCalc(args []string) error {
 		return fmt.Errorf("calc(%q): %w", args[0], err)
 	}
 	if len(args) == 2 {
-		dp, err := plainInt(args[1])
+		dp, err := intArg(args[1])
 		if err != nil {
 			return fmt.Errorf("calc decimals %w", err)
 		}