typia 13.1.0 → 13.1.19

package/native/core/factories/metadata_type_tag_factory_rejects_duplicated_array_form_tags_test.go

@@ -0,0 +1,41 @@
+package factories
+
+import (
+  "strings"
+  "testing"
+
+  schemametadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+)
+
+// TestMetadataTypeTagFactoryRejectsDuplicatedArrayFormTags verifies an array-form tag rejects a second tag of its own kind.
+//
+// Every array-form `exclusive` list names its own kind, so the tag can never be
+// duplicated. The check compared that list of kinds against the opposite tag's
+// `Name` — `"minimum"` against `"Minimum<0>"` — which never matches, so
+// `number & Minimum<5> & Minimum<0>` compiled and emitted `{"minimum": 0}`
+// while its validator required 5. This is one half of the mutation proof:
+// reverting the kind comparison back to `Name` turns this red. Restoring the
+// same-kind guard leaves this green, because a duplicate is same-kind; it reds
+// only the cross-kind rejection test instead.
+//
+// 1. Build two tags of one kind from each array-form declaration.
+// 2. Validate the pair and require rejection.
+// 3. Require the report to name the kind and the conflicting tag.
+func TestMetadataTypeTagFactoryRejectsDuplicatedArrayFormTags(t *testing.T) {
+  for _, declaration := range metadataTypeTagFactoryTestDeclarations() {
+    first := declaration.tag("A")
+    second := declaration.tag("B")
+    success, messages := metadataTypeTagFactoryTestValidate(
+      declaration.target,
+      []schemametadata.IMetadataTypeTag{first, second},
+    )
+    if success {
+      t.Fatalf("kind %s must not be duplicated on one property", declaration.kind)
+    }
+    if len(messages) != 1 ||
+      strings.Contains(messages[0], declaration.kind) == false ||
+      strings.Contains(messages[0], second.Name) == false {
+      t.Fatalf("the %s duplication report must name the conflict, reported %#v", declaration.kind, messages)
+    }
+  }
+}

package/native/core/factories/numeric_range_factory_enforces_64bit_bounds_test.go

@@ -0,0 +1,69 @@
+package factories
+
+import (
+  "testing"
+
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+// TestNumericRangeFactoryEnforces64BitBounds verifies 64-bit range predicates check something.
+//
+// ProtobufFactory routes only "int64" and "uint64" into the bigint path, so its
+// fall-through was the int64 case and returned a bare `true` keyword: a union
+// candidate typed `bigint & Type<"int64">` matched every magnitude. The bigint
+// path must therefore emit a real comparison, while every number predicate
+// bounds inclusively at its maximum (`2 ** 63 - 1`, `2 ** 64 - 1`, and the
+// exactly-representable 32-bit bounds).
+//
+// 1. Require neither bigint type to emit a bare `true` keyword.
+// 2. Require every number predicate to use an inclusive upper bound.
+func TestNumericRangeFactoryEnforces64BitBounds(t *testing.T) {
+  input := numericRangeFactory_factory.NewIdentifier("input")
+
+  for _, name := range []string{"int64", "uint64"} {
+    node := NumericRangeFactory.Bigint(name, input)
+    if node == nil {
+      t.Fatalf("bigint range %s returned nil", name)
+    }
+    if node.Kind == shimast.KindTrueKeyword {
+      t.Fatalf("bigint range %s emits a bare true keyword, so it checks nothing", name)
+    }
+  }
+
+  for _, name := range []string{"int32", "uint32", "int64", "uint64"} {
+    if numericRangeFactoryCountTokens(NumericRangeFactory.Number(name, input), shimast.KindLessThanToken) != 0 {
+      t.Fatalf("number range %s must bound its maximum inclusively", name)
+    }
+    if numericRangeFactoryCountTokens(NumericRangeFactory.Number(name, input), shimast.KindLessThanEqualsToken) != 2 {
+      t.Fatalf("number range %s must compare both bounds inclusively", name)
+    }
+  }
+}
+
+// numericRangeFactoryCountTokens counts binary operators of one kind in a predicate tree.
+func numericRangeFactoryCountTokens(node *shimast.Node, kind shimast.Kind) int {
+  if node == nil {
+    return 0
+  }
+  count := 0
+  var walk func(*shimast.Node)
+  walk = func(current *shimast.Node) {
+    if current == nil {
+      return
+    }
+    if current.Kind != shimast.KindBinaryExpression {
+      return
+    }
+    binary := current.AsBinaryExpression()
+    if binary == nil {
+      return
+    }
+    if binary.OperatorToken != nil && binary.OperatorToken.Kind == kind {
+      count++
+    }
+    walk(binary.Left)
+    walk(binary.Right)
+  }
+  walk(node)
+  return count
+}

package/native/core/factories/protobuf_recovery_ownership_test.go

@@ -0,0 +1,64 @@
+package factories
+
+import (
+  "slices"
+  "testing"
+
+  schemametadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+)
+
+// TestProtobufEmplacerRecoveryOwnership verifies unexpected panics stay visible.
+//
+// Unsupported metadata is diagnosed before emission, but an invariant failure
+// inside the Protobuf emplacer must not be converted into a successful semantic
+// result by a blanket recover.
+//
+//  1. Verify unsupported metadata remains an ordinary diagnostic.
+//  2. Build a static object with an impossible empty semantic schema.
+//  3. Require the panic to escape the post-validation emplacement pass.
+func TestProtobufEmplacerRecoveryOwnership(t *testing.T) {
+  unsupported := schemametadata.MetadataSchema_initialize()
+  unsupported.Any = true
+  errors := protobufFactory_validate()(struct {
+    Metadata *schemametadata.MetadataSchema
+    Explore  MetadataFactory_IExplore
+    Top      *schemametadata.MetadataSchema
+  }{
+    Metadata: unsupported,
+    Explore:  MetadataFactory_IExplore{Top: true},
+    Top:      unsupported,
+  })
+  if !slices.Contains(errors, "does not support any type") {
+    t.Fatalf("unsupported any fallback mismatch: %v", errors)
+  }
+
+  key := MetadataFactory.SoleLiteral("value")
+  dynamicKey := schemametadata.MetadataSchema_initialize()
+  dynamicKey.Atomics = append(dynamicKey.Atomics, schemametadata.MetadataAtomic_create(schemametadata.MetadataAtomic{Type: "string"}))
+  dynamic := schemametadata.MetadataObjectType_create(schemametadata.MetadataObjectType{
+    Name: "BrokenMap",
+    Properties: []*schemametadata.MetadataProperty{
+      schemametadata.MetadataProperty_create(schemametadata.MetadataProperty{
+        Key:   dynamicKey,
+        Value: schemametadata.MetadataSchema_initialize(),
+      }),
+    },
+  })
+  value := schemametadata.MetadataSchema_initialize()
+  value.Objects = append(value.Objects, schemametadata.MetadataObject_create(schemametadata.MetadataObject{Type: dynamic}))
+  object := schemametadata.MetadataObjectType_create(schemametadata.MetadataObjectType{
+    Name: "Broken",
+    Properties: []*schemametadata.MetadataProperty{
+      schemametadata.MetadataProperty_create(schemametadata.MetadataProperty{
+        Key:   key,
+        Value: value,
+      }),
+    },
+  })
+  defer func() {
+    if recover() == nil {
+      t.Fatal("unexpected Protobuf emplacer panic was swallowed")
+    }
+  }()
+  protobufFactory_emplaceObjects([]*schemametadata.MetadataObjectType{object})
+}

package/native/core/programmers/IsProgrammer.go

@@ -18,6 +18,7 @@ var IsProgrammer = isProgrammerNamespace{}
 
 type IsProgrammer_CONFIG_IOptions struct {
   Numeric   *bool
+  Finite    *bool
   Undefined *bool
   Object    func(props IsProgrammer_CONFIG_IOptions_ObjectProps) *shimast.Node
 }
@@ -182,6 +183,7 @@ func (isProgrammerNamespace) Decompose(props IsProgrammer_DecomposeProps) native
   f := nativecontext.EmitFactoryOf(isProgrammer_factory, props.Context.Emit)
   options := &IsProgrammer_CONFIG_IOptions{
     Numeric: props.Context.Options.Numeric,
+    Finite:  props.Context.Options.Finite,
     Object: func(v IsProgrammer_CONFIG_IOptions_ObjectProps) *shimast.Node {
       return nativeiterate.Check_object(nativeiterate.Check_objectProps{
         Config: nativeiterate.Check_object_IConfig{
@@ -397,8 +399,20 @@ func isProgrammer_binary(left *shimast.Expression, operator shimast.Kind, right
   )
 }
 
+// isProgrammer_option_numeric reports whether the number leaf gate must be
+// emitted at all. It opens on `finite` as well as `numeric` so that `finite:true`
+// alone rejects NaN and Infinity, matching how assert/validate open the same gate
+// via OptionPredicator.Numeric (which is likewise finite || numeric) and the
+// documented independence of the two flags (samchon/typia#2196). The gate only
+// decides whether check_number emits a guard; check_number's own inner selection
+// then picks Number.isFinite for `finite` or !Number.isNaN for `numeric`.
 func isProgrammer_option_numeric(options *IsProgrammer_CONFIG_IOptions) bool {
-  return options != nil && options.Numeric != nil && *options.Numeric
+  if options == nil {
+    return false
+  }
+  finite := options.Finite != nil && *options.Finite
+  numeric := options.Numeric != nil && *options.Numeric
+  return finite || numeric
 }
 
 func isProgrammer_option_undefined(options *IsProgrammer_CONFIG_IOptions) bool {

package/native/core/programmers/RandomProgrammer.go

@@ -615,27 +615,36 @@ type randomProgrammer_composedAtomic struct {
 func randomProgrammer_compose_atomic(atomicType string, schema nativeiterate.JsonSchema, emit *shimprinter.EmitContext) randomProgrammer_composedAtomic {
   f := nativecontext.EmitFactoryOf(randomProgrammer_factory, emit)
   if atomicType == "string" {
+    // A string leaf that also carries a length tag needs the bounds forwarded
+    // to the format and pattern generators; only the plain-string fall-through
+    // used to receive the full schema, so a format or pattern combined with
+    // minLength/maxLength was generated at the wrong length and failed its own
+    // validator (issue #2189).
+    lengthArgs := randomProgrammer_length_argument(schema, emit)
     if raw, ok := schema["format"].(string); ok && raw != "" {
       if raw == "date-time" {
-        return randomProgrammer_composedAtomic{Method: "datetime", Internal: "randomFormatDatetime"}
+        return randomProgrammer_composedAtomic{Method: "datetime", Internal: "randomFormatDatetime", Arguments: lengthArgs}
       }
       method := randomProgrammer_format_method(raw)
       return randomProgrammer_composedAtomic{
-        Method:   method,
-        Internal: "randomFormat" + randomProgrammer_format_pascal(raw),
+        Method:    method,
+        Internal:  "randomFormat" + randomProgrammer_format_pascal(raw),
+        Arguments: lengthArgs,
       }
     }
     if pattern, ok := schema["pattern"].(string); ok && pattern != "" {
+      arguments := []*shimast.Node{
+        f.NewNewExpression(
+          f.NewIdentifier("RegExp"),
+          nil,
+          f.NewNodeList([]*shimast.Node{f.NewStringLiteral(pattern, shimast.TokenFlagsNone)}),
+        ),
+      }
+      arguments = append(arguments, lengthArgs...)
       return randomProgrammer_composedAtomic{
-        Method:   "pattern",
-        Internal: "randomPattern",
-        Arguments: []*shimast.Node{
-          f.NewNewExpression(
-            f.NewIdentifier("RegExp"),
-            nil,
-            f.NewNodeList([]*shimast.Node{f.NewStringLiteral(pattern, shimast.TokenFlagsNone)}),
-          ),
-        },
+        Method:    "pattern",
+        Internal:  "randomPattern",
+        Arguments: arguments,
       }
     }
   } else if atomicType == "number" {
@@ -659,6 +668,24 @@ func randomProgrammer_compose_atomic(atomicType string, schema nativeiterate.Jso
   }
 }
 
+// randomProgrammer_length_argument forwards the minLength/maxLength bounds of a
+// string leaf to the format and pattern generators as a
+// `{ minLength?, maxLength? }` object literal, or nil when the leaf carries no
+// length tag so the format-only and pattern-only emission stays byte-identical.
+func randomProgrammer_length_argument(schema nativeiterate.JsonSchema, emit *shimprinter.EmitContext) []*shimast.Node {
+  length := map[string]any{}
+  if value, ok := schema["minLength"]; ok {
+    length["minLength"] = value
+  }
+  if value, ok := schema["maxLength"]; ok {
+    length["maxLength"] = value
+  }
+  if len(length) == 0 {
+    return nil
+  }
+  return []*shimast.Node{nativefactories.LiteralFactory.Write(length, emit)}
+}
+
 func randomProgrammer_decode_template(props struct {
   Context  nativecontext.ITypiaContext
   Functor  *nativehelpers.FunctionProgrammer
@@ -1407,6 +1434,16 @@ func randomProgrammer_is_typed_array(name string) bool {
   }
 }
 
+// randomProgrammer_typed_array_range reports the type tag and range a TypedArray's
+// elements are generated from.
+//
+// These bounds are a generation hint, not a validation gate, and they are the one
+// copy of the 64-bit bound that is deliberately inexact. They become `minimum` and
+// `maximum` comment tags on a number-typed JSON schema, and `number` cannot
+// represent 2**63 - 1 or 2**64 - 1 -- both arrive rounded up to the next power of
+// two. That costs nothing here: the generator only picks a value from the range,
+// and the TypedArray constructor wraps whatever it is handed. Validation owns
+// exactness instead, in _isTypeInt64Bigint and its siblings.
 func randomProgrammer_typed_array_range(name string) (string, string, string) {
   switch name {
   case "Uint8Array", "Uint8ClampedArray":
@@ -1424,9 +1461,9 @@ func randomProgrammer_typed_array_range(name string) (string, string, string) {
   case "Int32Array":
     return "int32", "-2147483648", "2147483647"
   case "BigInt64Array":
-    return "uint64", "-9223372036854775808", "9223372036854775807"
+    return "int64", "-9223372036854775808", "9223372036854775807"
   case "Float32Array":
-    return "float", "-1.175494351e38", "3.4028235e38"
+    return "float", "-3.4028235e38", "3.4028235e38"
   default:
     return "double", fmt.Sprint(math.SmallestNonzeroFloat64), fmt.Sprint(math.MaxFloat64)
   }