typia 14.0.6 → 15.0.1

package/native/core/factories/MetadataTypeTagFactory.go

@@ -141,7 +141,9 @@ func (metadataTypeTagFactoryNamespace) Analyze(props struct {
     }
   }
   if len(filtered) == 0 {
-    return []schemametadata.IMetadataTypeTag{}
+    // every tag object was malformed: their messages must still be reported,
+    // exactly as when a valid tag accompanies them (samchon/typia#2400)
+    return metadataTypeTagFactory_flush(props.Errors, props.Type, props.Objects, props.Explore, messages, []schemametadata.IMetadataTypeTag{})
   }
 
   tagList := []*metadataTypeTagFactory_ITypeTag{}
@@ -193,21 +195,35 @@ func (metadataTypeTagFactoryNamespace) Analyze(props struct {
     Tags:   output,
   })
 
-  if len(messages) > 0 {
-    if props.Errors != nil {
-      names := []string{props.Type}
-      for _, object := range props.Objects {
-        names = append(names, object.Name)
-      }
-      metadataTypeTagFactory_append_error(props.Errors, MetadataFactory_IError{
-        Name:     strings.Join(names, " & "),
-        Explore:  props.Explore,
-        Messages: messages,
-      })
+  return metadataTypeTagFactory_flush(props.Errors, props.Type, props.Objects, props.Explore, messages, output)
+}
+
+// metadataTypeTagFactory_flush reports the collected tag messages as one
+// error named after the tagged type, and then yields no tags; without
+// messages it yields the analyzed tags.
+func metadataTypeTagFactory_flush(
+  errors *[]MetadataFactory_IError,
+  typ string,
+  objects []*schemametadata.MetadataObjectType,
+  explore MetadataFactory_IExplore,
+  messages []string,
+  output []schemametadata.IMetadataTypeTag,
+) []schemametadata.IMetadataTypeTag {
+  if len(messages) == 0 {
+    return output
+  }
+  if errors != nil {
+    names := []string{typ}
+    for _, object := range objects {
+      names = append(names, object.Name)
     }
-    return []schemametadata.IMetadataTypeTag{}
+    metadataTypeTagFactory_append_error(errors, MetadataFactory_IError{
+      Name:     strings.Join(names, " & "),
+      Explore:  explore,
+      Messages: messages,
+    })
   }
-  return output
+  return []schemametadata.IMetadataTypeTag{}
 }
 
 func (metadataTypeTagFactoryNamespace) Validate(props struct {
@@ -315,12 +331,18 @@ func metadataTypeTagFactory_validate_property(props struct {
       Message  string
     }{Property: property, Message: "must be a string literal type"})
   }
-  if props.Key == "value" && !((props.Value.Size() == 0 && props.Value.IsRequired() == false) ||
-    (props.Value.Size() == 1 && (len(props.Value.Objects) == 1 || len(props.Value.Constants) == 1))) {
-    return props.Report(struct {
-      Property *string
-      Message  string
-    }{Property: property, Message: "must be a literal type or undefined value"})
+  // the value must be one concrete literal shape that the tag schema factory
+  // can materialize: a constant, `null`, a tuple of such values, or an object
+  // whose content reaches the schema through `schema`. `tags.Default` reads
+  // the value back, while `tags.Example` and `tags.Examples` only need the
+  // shape to be accepted (samchon/typia#2400, samchon/typia#2403)
+  if props.Key == "value" {
+    if _, ok := metadataTypeTagFactory_get_value(props.Value); ok == false {
+      return props.Report(struct {
+        Property *string
+        Message  string
+      }{Property: property, Message: "must be a literal, literal tuple, object, or undefined type"})
+    }
   }
   if props.Key == "exclusive" {
     return metadataTypeTagFactory_get_exclusive(struct {
@@ -344,11 +366,13 @@ func metadataTypeTagFactory_validate_property(props struct {
     }
     target := []string{}
     if len(props.Value.Objects) == 0 {
-      targetProperty := "target"
+      // `validate` itself is malformed here, e.g. a template literal built from
+      // a non-literal tag value, so name it rather than `target`
+      validateProperty := "validate"
       return props.Report(struct {
         Property *string
         Message  string
-      }{Property: &targetProperty, Message: "must be one of 'boolean', 'bigint', 'number', 'string', 'array', 'object"})
+      }{Property: &validateProperty, Message: "must be a string literal, or an object whose keys are 'boolean', 'bigint', 'number', 'string', 'array', or 'object'"})
     }
     for _, property := range props.Value.Objects[0].Type.Properties {
       if lit := property.Key.GetSoleLiteral(); lit != nil {
@@ -415,8 +439,8 @@ func metadataTypeTagFactory_create_metadata_type_tag(props struct {
   kind := fmt.Sprint(kindProperty.Value.Constants[0].Values[0].Value)
 
   var value any
-  if valueProperty := find("value"); valueProperty != nil && len(valueProperty.Value.Constants) != 0 && len(valueProperty.Value.Constants[0].Values) != 0 {
-    value = valueProperty.Value.Constants[0].Values[0].Value
+  if valueProperty := find("value"); valueProperty != nil {
+    value, _ = metadataTypeTagFactory_get_value(valueProperty.Value)
   }
   exclusive := metadataTypeTagFactory_get_exclusive(struct {
     Report func(struct {
@@ -490,6 +514,55 @@ func metadataTypeTagFactory_create_metadata_type_tag(props struct {
   }
 }
 
+// metadataTypeTagFactory_get_value reads a tag's `value` as one concrete
+// literal value, and reports whether the metadata names one at all. The
+// accepted shapes mirror what metadataTypeTagSchemaFactory_iterate can
+// materialize: `undefined`, `null`, a single constant, a fixed tuple of such
+// values, or an object. `null` and an object yield a Go nil value; a tuple
+// yields its members in order.
+func metadataTypeTagFactory_get_value(metadata *schemametadata.MetadataSchema) (any, bool) {
+  if metadata == nil {
+    return nil, false
+  }
+  if metadata.Size() == 0 {
+    // `null` is one literal value; a missing value is the optional `undefined`
+    return nil, metadata.Nullable || metadata.IsRequired() == false
+  }
+  if metadata.Size() != 1 || metadata.Nullable {
+    return nil, false
+  }
+  if len(metadata.Constants) == 1 && len(metadata.Constants[0].Values) == 1 {
+    return metadata.Constants[0].Values[0].Value, true
+  }
+  if metadata.Any || len(metadata.Arrays) != 0 || len(metadata.Atomics) != 0 || len(metadata.Natives) != 0 || len(metadata.Functions) != 0 {
+    return nil, false
+  }
+  if len(metadata.Tuples) == 1 {
+    tuple := metadata.Tuples[0].Type
+    if tuple.Recursive || tuple.IsRest() {
+      return nil, false
+    }
+    output := make([]any, 0, len(tuple.Elements))
+    for _, elem := range tuple.Elements {
+      if elem.IsRequired() == false {
+        return nil, false
+      }
+      value, ok := metadataTypeTagFactory_get_value(elem)
+      if ok == false {
+        return nil, false
+      }
+      output = append(output, value)
+    }
+    return output, true
+  }
+  if len(metadata.Objects) == 1 {
+    // Object-valued metadata predates tuple support. Its concrete value is
+    // carried by the tag's schema object rather than IMetadataTypeTag.Value.
+    return nil, true
+  }
+  return nil, false
+}
+
 func metadataTypeTagFactory_get_exclusive(props struct {
   Report func(struct {
     Property *string

package/native/core/factories/MetadataTypeTagSchemaFactory.go

@@ -33,6 +33,11 @@ func (metadataTypeTagSchemaFactoryNamespace) Object(props struct {
       metadata: property.Value,
     })
     if ok {
+      // a property literally typed `null` keeps its value; a Go nil would read
+      // as absent to every object writer (samchon/typia#2403)
+      if value == nil && property.Value.Nullable && property.Value.Size() == 0 {
+        value = LiteralFactory_Null{}
+      }
       output[*key] = value
     }
   }

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/internal/metadata/IMetadataIteratorProps.go

@@ -14,8 +14,12 @@ type MetadataFactory_IOptions struct {
   // method) into the collected properties as function-typed values, without
   // switching on full Functional analysis. Used by the compare programmers to
   // detect user-defined comparison methods.
-  Methods  bool
-  Validate func(props struct {
+  Methods bool
+  // StrictObjectMembers is for consumers whose emitted value promises to
+  // satisfy the entire input type. Include accessors and methods in the
+  // structural shape and diagnose members that have no JSON representation.
+  StrictObjectMembers bool
+  Validate            func(props struct {
     Metadata *schemametadata.MetadataSchema
     Explore  MetadataFactory_IExplore
     Top      *schemametadata.MetadataSchema

package/native/core/factories/internal/metadata/emplace_metadata_object.go

@@ -89,8 +89,40 @@ func Emplace_metadata_object(props IMetadataIteratorProps) *schemametadata.Metad
   }
 
   isClass := props.Type != nil && props.Type.IsClass()
-  isProperty := emplace_metadata_object_significant(props.Options.Functional, props.Options.Methods)
+  isProperty := emplace_metadata_object_significant(props.Options.Functional, props.Options.Methods, props.Options.StrictObjectMembers)
+  rejectMember := func(name string, message string) {
+    if props.Options.StrictObjectMembers == false || props.Errors == nil {
+      return
+    }
+    explore := props.Explore
+    explore.Top = false
+    explore.Object = obj
+    explore.Property = name
+    *props.Errors = append(*props.Errors, MetadataFactory_IError{
+      Name:     obj.Name,
+      Explore:  explore,
+      Messages: []string{message},
+    })
+  }
+  if props.Options.StrictObjectMembers && props.Checker != nil && props.Type != nil {
+    if len(props.Checker.GetSignaturesOfType(props.Type, nativechecker.SignatureKindCall)) != 0 {
+      rejectMember("[call]", "LLM evaluation does not support callable object types.")
+    }
+    if len(props.Checker.GetSignaturesOfType(props.Type, nativechecker.SignatureKindConstruct)) != 0 {
+      rejectMember("[construct]", "LLM evaluation does not support constructable object types.")
+    }
+  }
   pred := func(symbol *nativeast.Symbol, node *nativeast.Node) bool {
+    name := "<anonymous>"
+    if symbol != nil {
+      name = symbol.Name
+    }
+    // Diagnose ES #private before the symbol-key filter so JEV reports the
+    // nominal member rather than its compiler-generated mangled name.
+    if node != nil && (isClass || props.Options.StrictObjectMembers) && node.Name() != nil && node.Name().Kind == nativeast.KindPrivateIdentifier {
+      rejectMember(name, "LLM evaluation does not support private class members.")
+      return false
+    }
     // A `symbol`-keyed member (`[uniqueSymbol]: T`, `[Symbol.toStringTag]: T`,
     // ...) is not a string / number key: it is unreachable through the string
     // index access typia emits, `JSON.stringify` ignores it, and JSON Schema has
@@ -104,25 +136,21 @@ func Emplace_metadata_object(props IMetadataIteratorProps) *schemametadata.Metad
     // SYMBOL rather than a declaration node so a late-bound member with no
     // reachable declaration is excluded too.
     if symbol != nil && iterate_metadata_intersection_is_symbol_name(symbol.Name) {
+      rejectMember(name, "LLM evaluation does not support symbol-keyed properties.")
       return false
     }
     if node == nil {
       return true
     }
-    if isClass && node.ModifierFlags()&(nativeast.ModifierFlagsPrivate|nativeast.ModifierFlagsProtected) != 0 {
+    if (isClass || props.Options.StrictObjectMembers) && node.ModifierFlags()&(nativeast.ModifierFlagsPrivate|nativeast.ModifierFlagsProtected) != 0 {
+      rejectMember(name, "LLM evaluation does not support private or protected class members.")
       return false
     }
-    // An ES `#private` member (field, method, or accessor) carries no
-    // Private/Protected modifier — its identity is a KindPrivateIdentifier name.
-    // It is installed only by the constructor and is unreachable via index
-    // access, so it is not part of the structural shape; exclude it exactly as a
-    // `private`/`protected` keyword member (see ClassNonPublic). ApparentProperties
-    // otherwise surfaces it as a mangled key that no runtime object carries, so
-    // every real instance would fail its own guard (#2213).
-    if isClass && node.Name() != nil && node.Name().Kind == nativeast.KindPrivateIdentifier {
+    if isProperty(node) == false {
+      rejectMember(name, "LLM evaluation does not support this object member.")
       return false
     }
-    return isProperty(node)
+    return true
   }
 
   insert := func(next emplace_metadata_object_insert) *schemametadata.MetadataProperty {
@@ -135,7 +163,9 @@ func Emplace_metadata_object(props IMetadataIteratorProps) *schemametadata.Metad
   }
 
   for _, symbol := range props.Components.ApparentProperties(props.Checker, props.Type) {
-    if metadata_is_internal(symbol) {
+    // A complete-shape decoder must see even @internal members so its
+    // programmer can reject them; the ordinary structural consumers omit them.
+    if metadata_is_internal(symbol) && props.Options.StrictObjectMembers == false {
       continue
     }
     var node *nativeast.Node
@@ -188,6 +218,7 @@ func Emplace_metadata_object(props IMetadataIteratorProps) *schemametadata.Metad
     // intersections so every symbol-only form stays outside typia's structural
     // JSON shape, just like an explicit symbol-keyed member (#2240).
     if emplace_metadata_object_is_symbol_index_key(index.KeyType()) {
+      rejectMember("[symbol]", "LLM evaluation does not support symbol-keyed properties.")
       continue
     }
     analyzer := func(typ *nativechecker.Type) func(any) *schemametadata.MetadataSchema {
@@ -546,7 +577,7 @@ func emplace_metadata_object_intersection_append(
     return false
   }
   for _, symbol := range props.Components.ApparentProperties(props.Checker, child) {
-    if metadata_is_internal(symbol) {
+    if metadata_is_internal(symbol) && props.Options.StrictObjectMembers == false {
       continue
     }
     var node *nativeast.Node
@@ -652,10 +683,10 @@ func emplace_metadata_object_clone_property(property *schemametadata.MetadataPro
   })
 }
 
-func emplace_metadata_object_significant(functional bool, methods bool) func(node *nativeast.Node) bool {
+func emplace_metadata_object_significant(functional bool, methods bool, strict bool) func(node *nativeast.Node) bool {
   if functional {
     return func(node *nativeast.Node) bool {
-      return node.Kind != nativeast.KindGetAccessor && node.Kind != nativeast.KindSetAccessor
+      return strict || (node.Kind != nativeast.KindGetAccessor && node.Kind != nativeast.KindSetAccessor)
     }
   }
   return func(node *nativeast.Node) bool {
@@ -670,6 +701,9 @@ func emplace_metadata_object_significant(functional bool, methods bool) func(nod
     case nativeast.KindMethodDeclaration,
       nativeast.KindMethodSignature:
       return methods
+    case nativeast.KindGetAccessor,
+      nativeast.KindSetAccessor:
+      return strict
     default:
       return false
     }

package/native/core/factories/literal_factory_null_survives_objects_test.go

@@ -0,0 +1,43 @@
+package factories
+
+import (
+  "encoding/json"
+  "testing"
+)
+
+// TestLiteralFactoryNullSurvivesObjects verifies an explicit JSON null is kept
+// where a Go nil is dropped.
+//
+// Object writers treat a nil value as absent, so a tag schema holding a real
+// `null` (`tags.Example<null>`) lost it on emission (samchon/typia#2403). The
+// LiteralFactory_Null marker must survive encoding/json, which `typia.reflect`
+// metadata goes through, including inside an ordered object, and must not be
+// classified as nil-like, while a plain nil keeps meaning absent. The printed
+// literal path is covered by `test_json_schema_example_tuple_and_null`.
+//
+//  1. Marshal a map and an ordered object holding the marker and a plain nil.
+//  2. Assert the marker is written as null and the plain nil is omitted where
+//     the writer omits it.
+//  3. Assert the marker is not nil-like.
+func TestLiteralFactoryNullSurvivesObjects(t *testing.T) {
+  encoded, err := json.Marshal(map[string]any{"example": LiteralFactory_Null{}})
+  if err != nil || string(encoded) != `{"example":null}` {
+    t.Fatalf("map marker should marshal as null, got %s (%v)", encoded, err)
+  }
+  ordered, err := json.Marshal(LiteralFactory_OrderedObject{
+    Keys: []string{"kept", "absent"},
+    Values: map[string]any{
+      "kept":   LiteralFactory_Null{},
+      "absent": nil,
+    },
+  })
+  if err != nil || string(ordered) != `{"kept":null}` {
+    t.Fatalf("ordered object should keep the marker and drop nil, got %s (%v)", ordered, err)
+  }
+  if literalFactory_isNilLike(LiteralFactory_Null{}) {
+    t.Fatal("the null marker must not be nil-like")
+  }
+  if literalFactory_isNilLike(nil) == false {
+    t.Fatal("a plain nil must stay nil-like")
+  }
+}

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)
+      }
+    }
+  }
+}