typia 15.0.0 → 15.0.1

package/native/core/factories/MetadataCommentTagFactory.go

@@ -2,10 +2,12 @@ package factories
 
 import (
   "math"
+  "math/big"
   "strconv"
   "strings"
 
   schemametadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+  nativeutils "github.com/samchon/typia/packages/typia/native/core/utils"
 )
 
 type metadataCommentTagFactoryNamespace struct{}
@@ -51,6 +53,22 @@ func (metadataCommentTagFactoryNamespace) Analyze(props struct {
       continue
     }
     for key, value := range tagger {
+      // An empty arm names a target the tag's value cannot be stated for; see
+      // metadataCommentTagFactory_bigint. It is an error only where that target
+      // occurs, and the other arms still apply to theirs.
+      if value != nil && len(value) == 0 {
+        for _, atomic := range props.Metadata.Atomics {
+          if atomic.Type == key {
+            text := ""
+            if len(tag.Text) != 0 {
+              text = tag.Text[0].Text
+            }
+            report(key + " value " + strings.TrimSpace(text) + " is not an int64 integer that a number represents exactly")
+            break
+          }
+        }
+        continue
+      }
       filtered := []schemametadata.IMetadataTypeTag{}
       for _, elem := range value {
         filtered = append(filtered, elem)
@@ -230,37 +248,37 @@ var metadataCommentTagFactory_PARSER = map[string]metadataCommentTagFactory_pars
     Report func(msg string) any
     Value  string
   }) metadataCommentTagFactory_TagRecord {
-    value := metadataCommentTagFactory_parse_integer(struct {
+    value := metadataCommentTagFactory_value(metadataCommentTagFactory_parse_integer(struct {
       Report   func(msg string) any
       Unsigned bool
       Value    string
-    }{Report: props.Report, Value: props.Value, Unsigned: true})
+    }{Report: props.Report, Value: props.Value, Unsigned: true}))
     return metadataCommentTagFactory_TagRecord{"array": {
-      {Name: "MinItems<" + props.Value + ">", Target: "array", Kind: "minItems", Value: value, Validate: props.Value + " <= $input.length", Exclusive: metadataCommentTagFactory_exclusive("minItems"), Schema: map[string]any{"minItems": value}},
-      {Name: "MaxItems<" + props.Value + ">", Target: "array", Kind: "maxItems", Value: value, Validate: "$input.length <= " + props.Value, Exclusive: metadataCommentTagFactory_exclusive("maxItems"), Schema: map[string]any{"maxItems": value}},
+      {Name: "MinItems<" + props.Value + ">", Target: "array", Kind: "minItems", Value: value, Validate: metadataCommentTagFactory_splice(props.Value) + " <= $input.length", Exclusive: metadataCommentTagFactory_exclusive("minItems"), Schema: map[string]any{"minItems": value}},
+      {Name: "MaxItems<" + props.Value + ">", Target: "array", Kind: "maxItems", Value: value, Validate: "$input.length <= " + metadataCommentTagFactory_splice(props.Value), Exclusive: metadataCommentTagFactory_exclusive("maxItems"), Schema: map[string]any{"maxItems": value}},
     }}
   },
   "minItems": func(props struct {
     Report func(msg string) any
     Value  string
   }) metadataCommentTagFactory_TagRecord {
-    value := metadataCommentTagFactory_parse_integer(struct {
+    value := metadataCommentTagFactory_value(metadataCommentTagFactory_parse_integer(struct {
       Report   func(msg string) any
       Unsigned bool
       Value    string
-    }{Report: props.Report, Value: props.Value, Unsigned: true})
-    return metadataCommentTagFactory_TagRecord{"array": {{Name: "MinItems<" + props.Value + ">", Target: "array", Kind: "minItems", Value: value, Validate: props.Value + " <= $input.length", Exclusive: metadataCommentTagFactory_exclusive("minItems"), Schema: map[string]any{"minItems": value}}}}
+    }{Report: props.Report, Value: props.Value, Unsigned: true}))
+    return metadataCommentTagFactory_TagRecord{"array": {{Name: "MinItems<" + props.Value + ">", Target: "array", Kind: "minItems", Value: value, Validate: metadataCommentTagFactory_splice(props.Value) + " <= $input.length", Exclusive: metadataCommentTagFactory_exclusive("minItems"), Schema: map[string]any{"minItems": value}}}}
   },
   "maxItems": func(props struct {
     Report func(msg string) any
     Value  string
   }) metadataCommentTagFactory_TagRecord {
-    value := metadataCommentTagFactory_parse_integer(struct {
+    value := metadataCommentTagFactory_value(metadataCommentTagFactory_parse_integer(struct {
       Report   func(msg string) any
       Unsigned bool
       Value    string
-    }{Report: props.Report, Value: props.Value, Unsigned: true})
-    return metadataCommentTagFactory_TagRecord{"array": {{Name: "MaxItems<" + props.Value + ">", Target: "array", Kind: "maxItems", Value: value, Validate: "$input.length <= " + props.Value, Exclusive: metadataCommentTagFactory_exclusive("maxItems"), Schema: map[string]any{"maxItems": value}}}}
+    }{Report: props.Report, Value: props.Value, Unsigned: true}))
+    return metadataCommentTagFactory_TagRecord{"array": {{Name: "MaxItems<" + props.Value + ">", Target: "array", Kind: "maxItems", Value: value, Validate: "$input.length <= " + metadataCommentTagFactory_splice(props.Value), Exclusive: metadataCommentTagFactory_exclusive("maxItems"), Schema: map[string]any{"maxItems": value}}}}
   },
   "uniqueItems": func(props struct {
     Report func(msg string) any
@@ -273,25 +291,25 @@ var metadataCommentTagFactory_PARSER = map[string]metadataCommentTagFactory_pars
     Report func(msg string) any
     Value  string
   }) metadataCommentTagFactory_TagRecord {
-    return metadataCommentTagFactory_numeric(props, "Minimum", "minimum", props.Value+" <= $input", props.Value+" <= $input")
+    return metadataCommentTagFactory_numeric(props, "Minimum", "minimum", metadataCommentTagFactory_splice(props.Value)+" <= $input", metadataCommentTagFactory_splice_integer(props.Value)+" <= $input")
   },
   "maximum": func(props struct {
     Report func(msg string) any
     Value  string
   }) metadataCommentTagFactory_TagRecord {
-    return metadataCommentTagFactory_numeric(props, "Maximum", "maximum", "$input <= "+props.Value, "$input <= "+props.Value)
+    return metadataCommentTagFactory_numeric(props, "Maximum", "maximum", "$input <= "+metadataCommentTagFactory_splice(props.Value), "$input <= "+metadataCommentTagFactory_splice_integer(props.Value))
   },
   "exclusiveMinimum": func(props struct {
     Report func(msg string) any
     Value  string
   }) metadataCommentTagFactory_TagRecord {
-    return metadataCommentTagFactory_numeric(props, "ExclusiveMinimum", "exclusiveMinimum", props.Value+" < $input", props.Value+" < $input")
+    return metadataCommentTagFactory_numeric(props, "ExclusiveMinimum", "exclusiveMinimum", metadataCommentTagFactory_splice(props.Value)+" < $input", metadataCommentTagFactory_splice_integer(props.Value)+" < $input")
   },
   "exclusiveMaximum": func(props struct {
     Report func(msg string) any
     Value  string
   }) metadataCommentTagFactory_TagRecord {
-    return metadataCommentTagFactory_numeric(props, "ExclusiveMaximum", "exclusiveMaximum", "$input < "+props.Value, "$input < "+props.Value)
+    return metadataCommentTagFactory_numeric(props, "ExclusiveMaximum", "exclusiveMaximum", "$input < "+metadataCommentTagFactory_splice(props.Value), "$input < "+metadataCommentTagFactory_splice_integer(props.Value))
   },
   "multipleOf": func(props struct {
     Report func(msg string) any
@@ -303,7 +321,7 @@ var metadataCommentTagFactory_PARSER = map[string]metadataCommentTagFactory_pars
     // answers a different question than the `multipleOf` keyword this tag emits.
     // The bigint arm needs no helper: a bigint remainder is already exact.
     // `_isMultipleOf` first shipped in 13.1.19; see the doc comment above.
-    return metadataCommentTagFactory_numeric(props, "MultipleOf", "multipleOf", "$importInternal(\"_isMultipleOf\")($input, "+props.Value+")", "$input % "+props.Value+"n === 0n")
+    return metadataCommentTagFactory_numeric(props, "MultipleOf", "multipleOf", "$importInternal(\"_isMultipleOf\")($input, "+metadataCommentTagFactory_splice(props.Value)+")", "$input % "+metadataCommentTagFactory_splice_integer(props.Value)+"n === 0n")
   },
   "format": func(props struct {
     Report func(msg string) any
@@ -335,8 +353,8 @@ var metadataCommentTagFactory_PARSER = map[string]metadataCommentTagFactory_pars
     // The comparison helpers keep that code-point walk but stop when the
     // declared boundary already determines the answer.
     return metadataCommentTagFactory_TagRecord{"string": {
-      {Name: "MinLength<" + props.Value + ">", Target: "string", Kind: "minLength", Value: value, Validate: "$importInternal(\"_stringLengthGte\")($input, " + props.Value + ")", Exclusive: metadataCommentTagFactory_exclusive("minLength"), Schema: map[string]any{"minLength": value}},
-      {Name: "MaxLength<" + props.Value + ">", Target: "string", Kind: "maxLength", Value: value, Validate: "$importInternal(\"_stringLengthLte\")($input, " + props.Value + ")", Exclusive: metadataCommentTagFactory_exclusive("maxLength"), Schema: map[string]any{"maxLength": value}},
+      {Name: "MinLength<" + props.Value + ">", Target: "string", Kind: "minLength", Value: value, Validate: "$importInternal(\"_stringLengthGte\")($input, " + metadataCommentTagFactory_splice(props.Value) + ")", Exclusive: metadataCommentTagFactory_exclusive("minLength"), Schema: map[string]any{"minLength": value}},
+      {Name: "MaxLength<" + props.Value + ">", Target: "string", Kind: "maxLength", Value: value, Validate: "$importInternal(\"_stringLengthLte\")($input, " + metadataCommentTagFactory_splice(props.Value) + ")", Exclusive: metadataCommentTagFactory_exclusive("maxLength"), Schema: map[string]any{"maxLength": value}},
     }}
   },
   "minLength": func(props struct {
@@ -344,14 +362,14 @@ var metadataCommentTagFactory_PARSER = map[string]metadataCommentTagFactory_pars
     Value  string
   }) metadataCommentTagFactory_TagRecord {
     value := metadataCommentTagFactory_parse_number(props)
-    return metadataCommentTagFactory_TagRecord{"string": {{Name: "MinLength<" + props.Value + ">", Target: "string", Kind: "minLength", Value: value, Validate: "$importInternal(\"_stringLengthGte\")($input, " + props.Value + ")", Exclusive: metadataCommentTagFactory_exclusive("minLength"), Schema: map[string]any{"minLength": value}}}}
+    return metadataCommentTagFactory_TagRecord{"string": {{Name: "MinLength<" + props.Value + ">", Target: "string", Kind: "minLength", Value: value, Validate: "$importInternal(\"_stringLengthGte\")($input, " + metadataCommentTagFactory_splice(props.Value) + ")", Exclusive: metadataCommentTagFactory_exclusive("minLength"), Schema: map[string]any{"minLength": value}}}}
   },
   "maxLength": func(props struct {
     Report func(msg string) any
     Value  string
   }) metadataCommentTagFactory_TagRecord {
     value := metadataCommentTagFactory_parse_number(props)
-    return metadataCommentTagFactory_TagRecord{"string": {{Name: "MaxLength<" + props.Value + ">", Target: "string", Kind: "maxLength", Value: value, Validate: "$importInternal(\"_stringLengthLte\")($input, " + props.Value + ")", Exclusive: metadataCommentTagFactory_exclusive("maxLength"), Schema: map[string]any{"maxLength": value}}}}
+    return metadataCommentTagFactory_TagRecord{"string": {{Name: "MaxLength<" + props.Value + ">", Target: "string", Kind: "maxLength", Value: value, Validate: "$importInternal(\"_stringLengthLte\")($input, " + metadataCommentTagFactory_splice(props.Value) + ")", Exclusive: metadataCommentTagFactory_exclusive("maxLength"), Schema: map[string]any{"maxLength": value}}}}
   },
 }
 
@@ -480,31 +498,161 @@ func metadataCommentTagFactory_numeric(props struct {
   Value  string
 }, name string, kind string, numberValidate string, bigintValidate string) metadataCommentTagFactory_TagRecord {
   number := metadataCommentTagFactory_parse_number(props)
-  integer := metadataCommentTagFactory_parse_integer(struct {
-    Report   func(msg string) any
-    Unsigned bool
-    Value    string
-  }{Report: func(string) any { return nil }, Value: props.Value, Unsigned: false})
+  if number == nil {
+    // Reported as an invalid or non-finite number already; a record would only
+    // add "requires number type" on a bigint property, which is not the fault.
+    return metadataCommentTagFactory_TagRecord{}
+  }
   exclusive := metadataCommentTagFactory_exclusive(kind)
   record := metadataCommentTagFactory_TagRecord{
     "number": {{Name: name + "<" + props.Value + ">", Target: "number", Kind: kind, Value: number, Validate: numberValidate, Exclusive: exclusive, Schema: map[string]any{kind: number}}},
   }
-  if integer != nil {
-    record["bigint"] = []schemametadata.IMetadataTypeTag{{Name: name + "<" + props.Value + "n>", Target: "bigint", Kind: kind, Value: *integer, Validate: bigintValidate, Exclusive: exclusive, Schema: map[string]any{kind: number}}}
+  integer, numeric, ok := metadataCommentTagFactory_bigint(props.Value)
+  if ok {
+    record["bigint"] = []schemametadata.IMetadataTypeTag{{Name: name + "<" + props.Value + "n>", Target: "bigint", Kind: kind, Value: integer, Validate: bigintValidate, Exclusive: exclusive, Schema: map[string]any{kind: number}}}
+  } else if numeric {
+    // An empty arm: the value bounds a bigint, but not with any value this tag
+    // can state. `Analyze` reports it where a bigint occurs, so the bigint part
+    // of a `number | bigint` property is never left unconstrained silently.
+    record["bigint"] = []schemametadata.IMetadataTypeTag{}
   }
   return record
 }
 
+// metadataCommentTagFactory_bigint reads a numeric tag's value for its bigint
+// arm.
+//
+// Consumers of that arm hold the value as a double: the bound validators splice
+// a number literal, and the schema `random` draws from is numeric. The written
+// integer survives them only when a double represents it exactly, so that is
+// what the arm admits, within the int64 range its value is carried in
+// (samchon/typia#2352). Reading any integer through a double instead enforced
+// `@minimum 9007199254740993` as 9007199254740992, and let `random` generate
+// values the exact `@multipleOf` check rejects (samchon/typia#2457).
+//
+// numeric reports whether the text writes a finite number at all. One that is
+// no such integer -- `1.5`, `5.0000000000000001`, `9007199254740993`, or
+// `1e-1000001` -- is a bigint bound the tag cannot state, while text that is no
+// finite number has already been reported by the number arm.
+func metadataCommentTagFactory_bigint(text string) (value int64, numeric bool, ok bool) {
+  if reading := nativeutils.NumberUtil.Read(text); reading.Numeric == false || reading.Finite == false {
+    return 0, false, false
+  }
+  integer, exact := metadataCommentTagFactory_integer(text)
+  if exact == false || integer.IsInt64() == false {
+    return 0, true, false
+  }
+  if _, accuracy := new(big.Float).SetInt(integer).Float64(); accuracy != big.Exact {
+    return 0, true, false
+  }
+  return integer.Int64(), true, true
+}
+
+// metadataCommentTagFactory_integer is the integer a finite numeric text
+// writes exactly, if it writes one whose double lies within the int64 range. A
+// few integers just below -2^63 round to it and pass; the bigint record checks
+// the integer itself.
+//
+// Its double, which `NumberUtil.Read` rounds correctly, settles most texts
+// without expanding them. A non-integer double comes only from a non-integer
+// text, and a zero from a text with a non-zero digit is the underflow of a
+// non-integer. A double at 2^63 or above, or below -2^63, is refused too: the
+// int64 texts that round up to 2^63 (from 9223372036854775296) are no doubles,
+// so no bigint record could hold them anyway. `big.Rat` expands only what
+// remains, so a short text such as `@minimum 1e-1000000` costs nothing, on any
+// target.
+func metadataCommentTagFactory_integer(text string) (*big.Int, bool) {
+  reading := nativeutils.NumberUtil.Read(text)
+  if reading.Numeric == false ||
+    reading.Finite == false ||
+    reading.Value != math.Trunc(reading.Value) ||
+    reading.Value < metadataCommentTagFactory_INT64_MINIMUM ||
+    reading.Value >= metadataCommentTagFactory_INT64_EXCLUSIVE_MAXIMUM {
+    return nil, false
+  }
+  if reading.Value == 0 {
+    // A zero writes zero only when no digit before its exponent is non-zero;
+    // otherwise it underflowed. A radix zero has no `e`, being all zeros.
+    mantissa := text
+    if index := strings.IndexAny(text, "eE"); index != -1 {
+      mantissa = text[:index]
+    }
+    if strings.ContainsAny(mantissa, "123456789") {
+      return nil, false
+    }
+    return big.NewInt(0), true
+  }
+  rational, ok := nativeutils.NumberUtil.Rational(text)
+  if ok == false || rational.IsInt() == false {
+    return nil, false
+  }
+  return rational.Num(), true
+}
+
+// metadataCommentTagFactory_value unwraps a parsed count into the record's
+// value and schema. Storing the pointer itself let every consumer that formats
+// a value print an address: strict LLM schemas described `@minItems 2` as
+// `@minItems 0xc000012345`.
+func metadataCommentTagFactory_value(value *int64) any {
+  if value == nil {
+    return nil
+  }
+  return *value
+}
+
 func metadataCommentTagFactory_parse_number(props struct {
   Report func(msg string) any
   Value  string
 }) any {
-  parsed, err := strconv.ParseFloat(props.Value, 64)
-  if err != nil || math.IsNaN(parsed) {
+  reading := nativeutils.NumberUtil.Read(props.Value)
+  if reading.Numeric == false {
     props.Report("invalid number")
     return nil
   }
-  return parsed
+  // A JSON Schema keyword such as `minimum` must be a JSON number, and JSON has
+  // no spelling for an infinity (samchon/typia#2452).
+  if reading.Finite == false {
+    props.Report("non-finite number")
+    return nil
+  }
+  return reading.Value
+}
+
+// metadataCommentTagFactory_splice respells a numeric tag value for the
+// validator the record splices it into (`16 <= $input`, `$input % 1000n`).
+//
+// The spliced text has to be JavaScript for the value the tag was read as, in
+// both the number and the bigint target. The source spelling need not be:
+// `0x10` happens to be, but `1e3`, `1.0`, `+5`, and `007` are integers whose
+// bigint splice (`1e3n`, `1.0n`, `+5n`, `007n`) is no valid BigInt expression
+// (samchon/typia#2442). An integer spelling keeps its digits as written, so the
+// splice never rounds where the source did not: `Number()` would read
+// `9007199254740993` as ...992, while the bigint `@multipleOf` check appends
+// `n` to the digits and compares exactly.
+// Text that does not read as a finite number is passed through; the parser
+// reports it and nothing is emitted.
+func metadataCommentTagFactory_splice(value string) string {
+  if integer, ok := nativeutils.NumberUtil.Integer(value); ok {
+    return integer.String()
+  }
+  if reading := nativeutils.NumberUtil.Read(value); reading.Numeric && reading.Finite {
+    return nativeutils.NumberUtil.String(reading.Value)
+  }
+  return value
+}
+
+// metadataCommentTagFactory_splice_integer respells a tag value for a bigint
+// validator: the exact digits of the integer the text writes, whatever its
+// spelling, for every value a bigint record holds. `1.152921504606846976e18`
+// writes 2^60, while its double spells 1152921504606847000, which spliced
+// before an `n` would check a different integer (samchon/typia#2457). Text
+// that writes no integer has no bigint record, and falls back to the number
+// splice.
+func metadataCommentTagFactory_splice_integer(value string) string {
+  if integer, ok := metadataCommentTagFactory_integer(value); ok {
+    return integer.String()
+  }
+  return metadataCommentTagFactory_splice(value)
 }
 
 func metadataCommentTagFactory_parse_integer(props struct {

package/native/core/factories/expression_factory_number_spells_non_finite_values_test.go

@@ -0,0 +1,69 @@
+package factories
+
+import (
+  "math"
+  "testing"
+
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+// TestExpressionFactoryNumberSpellsNonFiniteValues verifies number literals for
+// NaN and the infinities.
+//
+// ExpressionFactory.Number built the literal text with `fmt.Sprint`, which
+// spells positive infinity `+Inf` and prints the magnitude of negative infinity
+// as `Inf`. Both reached the emit as identifiers JavaScript does not declare, so
+// every emitted schema, validator, or random bound carrying one threw
+// `ReferenceError: Inf is not defined` on its first run (samchon/typia#2452).
+// The expected shapes are the JavaScript globals TypeScript's own factory
+// prints. Finite values are the negative twin and must keep their literal.
+//
+//  1. Build numbers for NaN, positive and negative infinity.
+//  2. Assert they are the `NaN` / `Infinity` identifiers, negated for -Infinity.
+//  3. Assert finite values, negative ones, and zero keep numeric literals, with
+//     negative zero negated like any negative value rather than spelled `-0`
+//     inside one literal.
+func TestExpressionFactoryNumberSpellsNonFiniteValues(t *testing.T) {
+  identifier := func(node *shimast.Node, name string) bool {
+    return node != nil && node.Kind == shimast.KindIdentifier && node.Text() == name
+  }
+
+  if node := ExpressionFactory.Number(math.NaN()); identifier(node, "NaN") == false {
+    t.Fatalf("NaN should be the NaN identifier, got kind %v", node.Kind)
+  }
+  if node := ExpressionFactory.Number(math.Inf(1)); identifier(node, "Infinity") == false {
+    t.Fatalf("+Inf should be the Infinity identifier, got kind %v", node.Kind)
+  }
+  negative := ExpressionFactory.Number(math.Inf(-1))
+  if negative.Kind != shimast.KindPrefixUnaryExpression {
+    t.Fatalf("-Inf should be a negation, got kind %v", negative.Kind)
+  }
+  unary := negative.AsPrefixUnaryExpression()
+  if unary.Operator != shimast.KindMinusToken || identifier(unary.Operand, "Infinity") == false {
+    t.Fatal("-Inf should negate the Infinity identifier")
+  }
+
+  for _, item := range []struct {
+    value    any
+    negative bool
+    text     string
+  }{
+    {3, false, "3"},
+    {1.5, false, "1.5"},
+    {int64(0), false, "0"},
+    {-12, true, "12"},
+    {-2.5, true, "2.5"},
+    {math.Copysign(0, -1), true, "0"},
+  } {
+    node := ExpressionFactory.Number(item.value)
+    if item.negative {
+      if node.Kind != shimast.KindPrefixUnaryExpression {
+        t.Fatalf("%v should be a negation, got kind %v", item.value, node.Kind)
+      }
+      node = node.AsPrefixUnaryExpression().Operand
+    }
+    if node.Kind != shimast.KindNumericLiteral || node.Text() != item.text {
+      t.Fatalf("%v should be the numeric literal %q, got kind %v", item.value, item.text, node.Kind)
+    }
+  }
+}

package/native/core/factories/metadata_comment_tag_factory_holds_bigint_tags_exact_test.go

@@ -0,0 +1,168 @@
+package factories
+
+import (
+  "fmt"
+  "testing"
+
+  schemametadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+)
+
+// TestMetadataCommentTagFactoryHoldsBigintTagsExact verifies a numeric comment
+// tag states a bigint bound only when it can state it exactly.
+//
+// The bigint arm of `@minimum`, `@maximum`, `@exclusiveMinimum`,
+// `@exclusiveMaximum`, and `@multipleOf` read its value through a double, so
+// `@minimum 9007199254740993` was enforced as 9007199254740992: the bound
+// validators splice a number literal JavaScript rounds, and `random` drew from
+// the rounded schema while the `@multipleOf` check stayed exact
+// (samchon/typia#2457). Every consumer of the bigint record holds its value as
+// a double, so the record now admits an integer only when a double represents
+// it exactly, within the int64 range of samchon/typia#2352, and splices its
+// exact digits into the bigint check. A number target keeps reading the text
+// as `Number()` does.
+//
+//  1. Admit integers a double represents exactly, whatever their spelling, and
+//     splice their exact digits into the bigint check.
+//  2. Refuse every other finite value as a bigint bound: integers a double
+//     cannot represent, integers beyond int64, and non-integers, including
+//     ones `Number()` rounds to an integer.
+//  3. Report a refused value on a bigint property, and on the bigint part of a
+//     `number | bigint` one, while a number property and the number part
+//     still take the tag, and report text that is no finite number once.
+func TestMetadataCommentTagFactoryHoldsBigintTagsExact(t *testing.T) {
+  //----
+  // 1. exact integers
+  //----
+  for _, item := range []struct {
+    text  string
+    value int64
+  }{
+    {"9007199254740991", 9007199254740991},
+    {"9007199254740992", 9007199254740992},
+    {"18014398509481984", 18014398509481984},     // 2^54
+    {"54043195528445952", 54043195528445952},     // 3 * 2^54, although `String()` spells it ...950
+    {"1152921504606846976", 1152921504606846976}, // 2^60
+    {"1.152921504606846976e18", 1152921504606846976},
+    {"-9007199254740992", -9007199254740992},
+    {"1e3", 1000},
+    {"0x10", 16},
+    {"-0", 0},
+    {"0e999999999", 0},
+    {"0E5", 0},
+    {"0e99999999999999999999", 0}, // an exponent `big.Rat` cannot parse
+    {"0x0", 0},
+    {"10000000000000000", 10000000000000000},
+  } {
+    value, numeric, ok := metadataCommentTagFactory_bigint(item.text)
+    if ok == false || numeric == false || value != item.value {
+      t.Fatalf("%s must be the bigint %d, got %d (numeric=%v ok=%v)", item.text, item.value, value, numeric, ok)
+    }
+    if spliced := metadataCommentTagFactory_splice_integer(item.text); spliced != fmt.Sprint(item.value) {
+      t.Fatalf("%s must splice into a bigint check as %d, got %s", item.text, item.value, spliced)
+    }
+  }
+
+  //----
+  // 2. finite values no bigint tag states, and text that is no number
+  //----
+  for _, text := range []string{
+    "9007199254740993",     // rounds to ...992
+    "9007199254740993.0",   // the same integer, spelled with a point
+    "9.007199254740993e15", // and with an exponent
+    "-9007199254740993",
+    "0x20000000000001",     // 2^53 + 1 in hexadecimal
+    "1152921504606847000",  // `String(2 ** 60)`, which is not 2^60
+    "10000000000000000000", // beyond int64
+    "1.5",
+    "1e-3",
+    "5.0000000000000001", // `Number()` reads 5
+    "1e-400",             // `Number()` reads 0
+    "1e-1000001",         // underflows to 0, but writes no zero
+  } {
+    if _, numeric, ok := metadataCommentTagFactory_bigint(text); ok || numeric == false {
+      t.Fatalf("%s must be a finite value no bigint tag states (numeric=%v ok=%v)", text, numeric, ok)
+    }
+  }
+  for _, text := range []string{"Infinity", "abc", "1_000"} {
+    if _, numeric, ok := metadataCommentTagFactory_bigint(text); ok || numeric {
+      t.Fatalf("%s is no finite number (numeric=%v ok=%v)", text, numeric, ok)
+    }
+  }
+
+  //----
+  // 3. where the refusal is reported
+  //----
+  analyze := func(types []string, name string, text string) (*schemametadata.MetadataSchema, []string) {
+    atomics := []*schemametadata.MetadataAtomic{}
+    for _, typ := range types {
+      atomics = append(atomics, schemametadata.MetadataAtomic_create(schemametadata.MetadataAtomic{Type: typ}))
+    }
+    meta := schemametadata.MetadataSchema_create(schemametadata.MetadataSchema{Atomics: atomics})
+    errors := []MetadataFactory_IError{}
+    MetadataCommentTagFactory.Analyze(struct {
+      Errors   *[]MetadataFactory_IError
+      Metadata *schemametadata.MetadataSchema
+      Tags     []schemametadata.IJsDocTagInfo
+      Explore  MetadataFactory_IExplore
+    }{
+      Errors:   &errors,
+      Metadata: meta,
+      Tags:     []schemametadata.IJsDocTagInfo{{Name: name, Text: []schemametadata.IJsDocTagInfo_IText{{Text: text}}}},
+    })
+    messages := []string{}
+    for _, err := range errors {
+      messages = append(messages, err.Messages...)
+    }
+    return meta, messages
+  }
+  refusal := "bigint value 9007199254740993 is not an int64 integer that a number represents exactly"
+  for _, name := range []string{"minimum", "maximum", "exclusiveMinimum", "exclusiveMaximum", "multipleOf"} {
+    if _, messages := analyze([]string{"bigint"}, name, "9007199254740993"); len(messages) != 1 || messages[0] != refusal {
+      t.Fatalf("@%s on a bigint must report the refusal alone, got %#v", name, messages)
+    }
+    meta, messages := analyze([]string{"number"}, name, "9007199254740993")
+    if len(messages) != 0 || len(meta.Atomics[0].Tags) != 1 {
+      t.Fatalf("@%s on a number must apply, got %#v", name, messages)
+    }
+    meta, messages = analyze([]string{"number", "bigint"}, name, "9007199254740993")
+    if len(messages) != 1 || messages[0] != refusal {
+      t.Fatalf("@%s on number | bigint must report the bigint part, got %#v", name, messages)
+    }
+    if len(meta.Atomics[0].Tags) != 1 || len(meta.Atomics[1].Tags) != 0 {
+      t.Fatalf("@%s on number | bigint must constrain the number part only", name)
+    }
+    if meta, messages := analyze([]string{"bigint"}, name, "9007199254740992"); len(messages) != 0 || len(meta.Atomics[0].Tags) != 1 {
+      t.Fatalf("@%s 9007199254740992 on a bigint must apply, got %#v", name, messages)
+    }
+  }
+  // A value `Number()` rounds to an integer still names no bigint bound: the
+  // number part takes it as 5, and the bigint part is reported, not dropped.
+  meta, messages := analyze([]string{"number", "bigint"}, "minimum", "5.0000000000000001")
+  if len(messages) != 1 || messages[0] != "bigint value 5.0000000000000001 is not an int64 integer that a number represents exactly" {
+    t.Fatalf("@minimum 5.0000000000000001 on number | bigint must report the bigint part, got %#v", messages)
+  }
+  if len(meta.Atomics[0].Tags) != 1 || meta.Atomics[0].Tags[0][0].Validate != "5 <= $input" || len(meta.Atomics[1].Tags) != 0 {
+    t.Fatal("@minimum 5.0000000000000001 on number | bigint must constrain the number part only")
+  }
+  if _, messages := analyze([]string{"bigint"}, "minimum", "1.5"); len(messages) != 1 || messages[0] != "bigint value 1.5 is not an int64 integer that a number represents exactly" {
+    t.Fatalf("@minimum 1.5 on a bigint must be refused, got %#v", messages)
+  }
+  if _, messages := analyze([]string{"number", "bigint"}, "minimum", "1e-1000001"); len(messages) != 1 || messages[0] != "bigint value 1e-1000001 is not an int64 integer that a number represents exactly" {
+    t.Fatalf("@minimum 1e-1000001 on number | bigint must report the bigint part, got %#v", messages)
+  }
+  // Text that is no finite number is reported once, as such, on any target.
+  for _, item := range []struct {
+    text    string
+    message string
+  }{
+    {"abc", "invalid number"},
+    {"Infinity", "non-finite number"},
+    {"1e400", "non-finite number"},
+  } {
+    for _, types := range [][]string{{"bigint"}, {"number", "bigint"}} {
+      if _, messages := analyze(types, "minimum", item.text); len(messages) != 1 || messages[0] != item.message {
+        t.Fatalf("@minimum %s on %v must report %q alone, got %#v", item.text, types, item.message, messages)
+      }
+    }
+  }
+}