typia 13.1.1 → 13.1.19

package/native/core/programmers/iterate/check_template.go

@@ -1,6 +1,7 @@
 package iterate
 
 import (
+  "fmt"
   "strings"
 
   shimast "github.com/microsoft/typescript-go/shim/ast"
@@ -32,8 +33,10 @@ func Check_template(props Check_templateProps) nativehelpers.ICheckEntry {
   internal := make([]*shimast.Node, 0, len(props.Templates))
   var solePattern string
   var soleCaptures []templateCapture
+  var soleBacktracking *nativehelpers.ICheckEntry_ICondition
   for _, tpl := range props.Templates {
     pattern, captures := template_runtime_pattern(tpl.Row)
+    backtracking := template_requires_backtracking(tpl.Row)
     expression := f.NewCallExpression(
       f.NewIdentifier("RegExp(/"+pattern+"/).test"),
       nil,
@@ -46,6 +49,16 @@ func Check_template(props Check_templateProps) nativehelpers.ICheckEntry {
     // them — both the whole-string matrix and the per-placeholder
     // interpolation matrix — into the member expression instead.
     if len(props.Templates) > 1 {
+      if backtracking {
+        expression = f.NewBinaryExpression(
+          nil,
+          expression,
+          nil,
+          f.NewToken(shimast.KindAmpersandAmpersandToken),
+          check_template_backtracking(props, tpl),
+        )
+        captures = nil
+      }
       if tags := check_template_inline_all_tags(props, tpl, pattern, captures); tags != nil {
         expression = f.NewBinaryExpression(
           nil,
@@ -57,7 +70,15 @@ func Check_template(props Check_templateProps) nativehelpers.ICheckEntry {
       }
     } else {
       solePattern = pattern
-      soleCaptures = captures
+      if backtracking {
+        soleCaptures = nil
+        soleBacktracking = &nativehelpers.ICheckEntry_ICondition{
+          Expected:   check_template_backtracking_expected(tpl),
+          Expression: check_template_backtracking(props, tpl),
+        }
+      } else {
+        soleCaptures = captures
+      }
     }
     internal = append(internal, expression)
   }
@@ -74,7 +95,7 @@ func Check_template(props Check_templateProps) nativehelpers.ICheckEntry {
     Expected:   strings.Join(names, " | "),
   }
   if len(props.Templates) == 1 {
-    entry.Conditions = check_template_all_conditions(props, props.Templates[0], solePattern, soleCaptures)
+    entry.Conditions = check_template_all_conditions(props, props.Templates[0], solePattern, soleCaptures, soleBacktracking)
   }
   return entry
 }
@@ -114,10 +135,10 @@ func check_template_type_tags(props Check_templateProps, tpl *nativemetadata.Met
 // must hold simultaneously, so all matrices collapse into a single AND row:
 // single-row matrices keep one ICondition per tag (so validate still names the
 // exact tag), while a multi-row (union) matrix collapses to one OR'd ICondition.
-func check_template_all_conditions(props Check_templateProps, tpl *nativemetadata.MetadataTemplate, pattern string, captures []templateCapture) [][]nativehelpers.ICheckEntry_ICondition {
+func check_template_all_conditions(props Check_templateProps, tpl *nativemetadata.MetadataTemplate, pattern string, captures []templateCapture, backtracking *nativehelpers.ICheckEntry_ICondition) [][]nativehelpers.ICheckEntry_ICondition {
   wholeString := check_template_type_tags(props, tpl)
   groups := check_template_placeholder_groups(props, tpl, pattern, captures)
-  if len(groups) == 0 {
+  if len(groups) == 0 && backtracking == nil {
     return wholeString
   }
   // groups is non-empty here, and every group contributes at least one
@@ -127,6 +148,9 @@ func check_template_all_conditions(props Check_templateProps, tpl *nativemetadat
   for _, group := range groups {
     check_template_append_matrix(&row, group, props.Emit)
   }
+  if backtracking != nil {
+    row = append(row, *backtracking)
+  }
   return [][]nativehelpers.ICheckEntry_ICondition{row}
 }
 
@@ -182,22 +206,31 @@ func check_template_placeholder_groups(props Check_templateProps, tpl *nativemet
 // this placeholder only because template_fully_constrained holds, i.e. each row
 // carries a validate-able tag, so no produced row is empty.
 func check_template_capture_conditions(props Check_templateProps, base string, pattern string, capture templateCapture) [][]nativehelpers.ICheckEntry_ICondition {
+  return check_template_value_conditions(
+    props,
+    base,
+    capture.Atomic,
+    capture.Kind,
+    check_template_capture_input(pattern, capture, props.Input, props.Emit),
+  )
+}
+
+func check_template_value_conditions(props Check_templateProps, base string, atomic *nativemetadata.MetadataAtomic, kind string, input *shimast.Expression) [][]nativehelpers.ICheckEntry_ICondition {
   output := [][]nativehelpers.ICheckEntry_ICondition{}
-  for _, row := range capture.Atomic.Tags {
+  for _, row := range atomic.Tags {
     conditions := []nativehelpers.ICheckEntry_ICondition{}
-    if capture.Kind != "string" {
-      // number and bigint share the numeric transpiler; the bigint validate
-      // scripts already compare via `BigInt(...)`, and check_template_capture_input
-      // hands them a `BigInt(...)`-parsed value. The exclude literals use
-      // capture.Kind so a bigint placeholder emits bigint literals.
+    if kind != "string" {
+      // Number and bigint share the numeric transpiler. Coercion stays here so
+      // both direct RegExp captures and backtracking slices use the same tag
+      // predicates, while bigint exclude checks still emit bigint literals.
       for _, tag := range check_number_filter_validate(row) {
         conditions = append(conditions, nativehelpers.ICheckEntry_ICondition{
           Expected:   base + " & " + tag.Name,
-          Expression: check_number_transpile(props.Context, tag.Validate)(check_template_capture_input(pattern, capture, props.Input, props.Emit)),
+          Expression: check_number_transpile(props.Context, tag.Validate)(check_template_coerce_input(kind, input, props.Emit)),
         })
       }
       for _, tag := range row {
-        if condition := check_exclude_condition(capture.Kind, tag, check_template_capture_input(pattern, capture, props.Input, props.Emit), props.Emit); condition != nil {
+        if condition := check_exclude_condition(kind, tag, check_template_coerce_input(kind, input, props.Emit), props.Emit); condition != nil {
           conditions = append(conditions, *condition)
         }
       }
@@ -205,11 +238,11 @@ func check_template_capture_conditions(props Check_templateProps, base string, p
       for _, tag := range check_string_filter_validate(row) {
         conditions = append(conditions, nativehelpers.ICheckEntry_ICondition{
           Expected:   base + " & " + tag.Name,
-          Expression: check_string_transpile(props.Context, tag.Validate)(check_template_capture_input(pattern, capture, props.Input, props.Emit)),
+          Expression: check_string_transpile(props.Context, tag.Validate)(input),
         })
       }
       for _, tag := range row {
-        if condition := check_exclude_condition("string", tag, check_template_capture_input(pattern, capture, props.Input, props.Emit), props.Emit); condition != nil {
+        if condition := check_exclude_condition("string", tag, input, props.Emit); condition != nil {
           conditions = append(conditions, *condition)
         }
       }
@@ -219,13 +252,33 @@ func check_template_capture_conditions(props Check_templateProps, base string, p
   return output
 }
 
-// check_template_capture_input builds the expression that re-extracts a
-// placeholder's captured substring: `RegExp(/pattern/).exec(input)[index]`,
-// coerced through `Number(...)` for a numeric placeholder or `BigInt(...)` for a
-// bigint one (a string placeholder uses the raw substring). The surrounding
-// `.test()` (entry expression for a sole template, member expression for a
-// union) guarantees the match is non-null, and the bigint capture pattern admits
-// only integers, so the conversion never throws.
+func check_template_coerce_input(kind string, input *shimast.Expression, emit *shimprinter.EmitContext) *shimast.Expression {
+  f := nativecontext.EmitFactoryOf(check_template_factory, emit)
+  coerce := ""
+  switch kind {
+  case "number":
+    coerce = "Number"
+  case "bigint":
+    coerce = "BigInt"
+  }
+  if coerce == "" {
+    return input
+  }
+  return f.NewCallExpression(
+    f.NewIdentifier(coerce),
+    nil,
+    nil,
+    f.NewNodeList([]*shimast.Node{input}),
+    shimast.NodeFlagsNone,
+  )
+}
+
+// check_template_capture_input re-extracts a placeholder's raw captured
+// substring: `RegExp(/pattern/).exec(input)[index]`. The surrounding `.test()`
+// (entry expression for a sole template, member expression for a union)
+// guarantees the match is non-null. Numeric coercion belongs to
+// check_template_value_conditions so direct captures and backtracking slices
+// share the same path.
 func check_template_capture_input(pattern string, capture templateCapture, input *shimast.Expression, emit *shimprinter.EmitContext) *shimast.Expression {
   f := nativecontext.EmitFactoryOf(check_template_factory, emit)
   element := f.NewElementAccessExpression(
@@ -240,23 +293,282 @@ func check_template_capture_input(pattern string, capture templateCapture, input
     nativefactories.ExpressionFactory.Number(capture.Index, emit),
     shimast.NodeFlagsNone,
   )
-  coerce := ""
-  switch capture.Kind {
-  case "number":
-    coerce = "Number"
-  case "bigint":
-    coerce = "BigInt"
+  return element
+}
+
+// check_template_backtracking accepts a template when at least one complete
+// assignment of substrings to placeholders satisfies both their structural
+// patterns and every runtime-checkable tag. One memoized visitor per template
+// row enumerates UTF-16 offsets, matching JavaScript string slicing and RegExp
+// semantics without repeating the same suffix search or committing to
+// RegExp.exec's single greedy capture.
+func check_template_backtracking(props Check_templateProps, tpl *nativemetadata.MetadataTemplate) *shimast.Node {
+  f := nativecontext.EmitFactoryOf(check_template_factory, props.Emit)
+  statements := make([]*shimast.Node, 0, (len(tpl.Row)+1)*2+1)
+  for index := 0; index <= len(tpl.Row); index++ {
+    memoName := fmt.Sprintf("_templateMemo%d", index)
+    visitName := fmt.Sprintf("_templateVisit%d", index)
+    offsetName := fmt.Sprintf("_templateStart%d", index)
+    cachedName := fmt.Sprintf("_templateCached%d", index)
+    resultName := fmt.Sprintf("_templateResult%d", index)
+    offset := f.NewIdentifier(offsetName)
+    memo := f.NewIdentifier(memoName)
+
+    statements = append(statements,
+      nativefactories.StatementFactory.Constant(nativefactories.StatementFactory_ConstantProps{
+        Name:  memoName,
+        Value: f.NewNewExpression(f.NewIdentifier("Map"), nil, f.NewNodeList(nil)),
+      }, props.Emit),
+      nativefactories.StatementFactory.Constant(nativefactories.StatementFactory_ConstantProps{
+        Name: visitName,
+        Value: f.NewArrowFunction(
+          nil,
+          nil,
+          f.NewNodeList([]*shimast.Node{
+            nativefactories.IdentifierFactory.Parameter(offsetName, nativefactories.TypeFactory.Keyword("number", props.Emit), nil, props.Emit),
+          }),
+          nativefactories.TypeFactory.Keyword("boolean", props.Emit),
+          nil,
+          f.NewToken(shimast.KindEqualsGreaterThanToken),
+          f.NewBlock(f.NewNodeList([]*shimast.Node{
+            nativefactories.StatementFactory.Constant(nativefactories.StatementFactory_ConstantProps{
+              Name: cachedName,
+              Value: f.NewCallExpression(
+                nativefactories.IdentifierFactory.Access(props.Emit, memo, "get"),
+                nil,
+                nil,
+                f.NewNodeList([]*shimast.Node{offset}),
+                shimast.NodeFlagsNone,
+              ),
+            }, props.Emit),
+            f.NewIfStatement(
+              f.NewBinaryExpression(
+                nil,
+                f.NewIdentifier(cachedName),
+                nil,
+                f.NewToken(shimast.KindExclamationEqualsEqualsToken),
+                f.NewIdentifier("undefined"),
+              ),
+              f.NewReturnStatement(f.NewIdentifier(cachedName)),
+              nil,
+            ),
+            nativefactories.StatementFactory.Constant(nativefactories.StatementFactory_ConstantProps{
+              Name:  resultName,
+              Type:  nativefactories.TypeFactory.Keyword("boolean", props.Emit),
+              Value: check_template_backtracking_step(props, tpl, index, offset),
+            }, props.Emit),
+            f.NewExpressionStatement(f.NewCallExpression(
+              nativefactories.IdentifierFactory.Access(props.Emit, memo, "set"),
+              nil,
+              nil,
+              f.NewNodeList([]*shimast.Node{offset, f.NewIdentifier(resultName)}),
+              shimast.NodeFlagsNone,
+            )),
+            f.NewReturnStatement(f.NewIdentifier(resultName)),
+          }), true),
+        ),
+      }, props.Emit),
+    )
+  }
+  statements = append(statements, f.NewReturnStatement(check_template_backtracking_call(
+    0,
+    nativefactories.ExpressionFactory.Number(0, props.Emit),
+    props.Emit,
+  )))
+  return f.NewCallExpression(
+    f.NewParenthesizedExpression(f.NewArrowFunction(
+      nil,
+      nil,
+      f.NewNodeList(nil),
+      nativefactories.TypeFactory.Keyword("boolean", props.Emit),
+      nil,
+      f.NewToken(shimast.KindEqualsGreaterThanToken),
+      f.NewBlock(f.NewNodeList(statements), true),
+    )),
+    nil,
+    nil,
+    nil,
+    shimast.NodeFlagsNone,
+  )
+}
+
+func check_template_backtracking_step(props Check_templateProps, tpl *nativemetadata.MetadataTemplate, index int, offset *shimast.Expression) *shimast.Node {
+  f := nativecontext.EmitFactoryOf(check_template_factory, props.Emit)
+  if index == len(tpl.Row) {
+    return f.NewBinaryExpression(
+      nil,
+      offset,
+      nil,
+      f.NewToken(shimast.KindEqualsEqualsEqualsToken),
+      nativefactories.IdentifierFactory.Access(props.Emit, props.Input, "length"),
+    )
   }
-  if coerce != "" {
-    return f.NewCallExpression(
-      f.NewIdentifier(coerce),
+  meta := tpl.Row[index]
+  if literal, ok := template_literal_value(meta); ok {
+    value := f.NewStringLiteral(literal, shimast.TokenFlagsNone)
+    starts := f.NewCallExpression(
+      nativefactories.IdentifierFactory.Access(props.Emit, props.Input, "startsWith"),
       nil,
       nil,
-      f.NewNodeList([]*shimast.Node{element}),
+      f.NewNodeList([]*shimast.Node{value, offset}),
       shimast.NodeFlagsNone,
     )
+    nextOffset := f.NewBinaryExpression(
+      nil,
+      offset,
+      nil,
+      f.NewToken(shimast.KindPlusToken),
+      nativefactories.IdentifierFactory.Access(props.Emit, value, "length"),
+    )
+    return f.NewBinaryExpression(
+      nil,
+      starts,
+      nil,
+      f.NewToken(shimast.KindAmpersandAmpersandToken),
+      check_template_backtracking_call(index+1, nextOffset, props.Emit),
+    )
   }
-  return element
+
+  endName := fmt.Sprintf("_templateEnd%d", index)
+  end := f.NewIdentifier(endName)
+  slice := f.NewCallExpression(
+    nativefactories.IdentifierFactory.Access(props.Emit, props.Input, "slice"),
+    nil,
+    nil,
+    f.NewNodeList([]*shimast.Node{offset, end}),
+    shimast.NodeFlagsNone,
+  )
+  conditions := []*shimast.Node{
+    f.NewCallExpression(
+      f.NewIdentifier("RegExp(/"+template_backtracking_pattern(meta)+"/).test"),
+      nil,
+      nil,
+      f.NewNodeList([]*shimast.Node{slice}),
+      shimast.NodeFlagsNone,
+    ),
+  }
+  if atomic, kind, ok := template_constrained_capture(meta); ok {
+    conditions = append(conditions, check_template_condition_matrix(check_template_value_conditions(
+      props,
+      tpl.GetBaseName(),
+      atomic,
+      kind,
+      slice,
+    ), props.Emit))
+  }
+  conditions = append(conditions, check_template_backtracking_call(index+1, end, props.Emit))
+
+  length := f.NewBinaryExpression(
+    nil,
+    f.NewBinaryExpression(
+      nil,
+      nativefactories.IdentifierFactory.Access(props.Emit, props.Input, "length"),
+      nil,
+      f.NewToken(shimast.KindMinusToken),
+      offset,
+    ),
+    nil,
+    f.NewToken(shimast.KindPlusToken),
+    nativefactories.ExpressionFactory.Number(1, props.Emit),
+  )
+  positionName := fmt.Sprintf("_templateOffset%d", index)
+  candidates := f.NewCallExpression(
+    f.NewIdentifier("Array.from"),
+    nil,
+    nil,
+    f.NewNodeList([]*shimast.Node{
+      f.NewObjectLiteralExpression(f.NewNodeList([]*shimast.Node{
+        f.NewPropertyAssignment(nil, f.NewIdentifier("length"), nil, nil, length),
+      }), false),
+      f.NewArrowFunction(
+        nil,
+        nil,
+        f.NewNodeList([]*shimast.Node{
+          nativefactories.IdentifierFactory.Parameter(fmt.Sprintf("_templateUnused%d", index), nil, nil, props.Emit),
+          nativefactories.IdentifierFactory.Parameter(positionName, nativefactories.TypeFactory.Keyword("number", props.Emit), nil, props.Emit),
+        }),
+        nil,
+        nil,
+        f.NewToken(shimast.KindEqualsGreaterThanToken),
+        f.NewBinaryExpression(
+          nil,
+          offset,
+          nil,
+          f.NewToken(shimast.KindPlusToken),
+          f.NewIdentifier(positionName),
+        ),
+      ),
+    }),
+    shimast.NodeFlagsNone,
+  )
+  return f.NewCallExpression(
+    nativefactories.IdentifierFactory.Access(props.Emit, candidates, "some"),
+    nil,
+    nil,
+    f.NewNodeList([]*shimast.Node{
+      f.NewArrowFunction(
+        nil,
+        nil,
+        f.NewNodeList([]*shimast.Node{
+          nativefactories.IdentifierFactory.Parameter(endName, nativefactories.TypeFactory.Keyword("number", props.Emit), nil, props.Emit),
+        }),
+        nil,
+        nil,
+        f.NewToken(shimast.KindEqualsGreaterThanToken),
+        check_template_reduce(conditions, shimast.KindAmpersandAmpersandToken, props.Emit),
+      ),
+    }),
+    shimast.NodeFlagsNone,
+  )
+}
+
+func check_template_backtracking_call(index int, offset *shimast.Expression, emit *shimprinter.EmitContext) *shimast.Node {
+  f := nativecontext.EmitFactoryOf(check_template_factory, emit)
+  return f.NewCallExpression(
+    f.NewIdentifier(fmt.Sprintf("_templateVisit%d", index)),
+    nil,
+    nil,
+    f.NewNodeList([]*shimast.Node{offset}),
+    shimast.NodeFlagsNone,
+  )
+}
+
+func check_template_condition_matrix(matrix [][]nativehelpers.ICheckEntry_ICondition, emit *shimprinter.EmitContext) *shimast.Node {
+  rows := make([]*shimast.Node, 0, len(matrix))
+  for _, row := range matrix {
+    columns := make([]*shimast.Node, 0, len(row))
+    for _, condition := range row {
+      columns = append(columns, condition.Expression)
+    }
+    rows = append(rows, check_template_reduce(columns, shimast.KindAmpersandAmpersandToken, emit))
+  }
+  return check_template_reduce(rows, shimast.KindBarBarToken, emit)
+}
+
+func check_template_backtracking_expected(tpl *nativemetadata.MetadataTemplate) string {
+  names := []string{}
+  seen := map[string]bool{}
+  for _, meta := range tpl.Row {
+    atomic, _, ok := template_constrained_capture(meta)
+    if ok == false {
+      continue
+    }
+    for _, row := range atomic.Tags {
+      for _, tag := range row {
+        if tag.Validate == "" && (tag.Kind != "exclude" || len(check_exclude_values(tag)) == 0) {
+          continue
+        }
+        if seen[tag.Name] == false {
+          seen[tag.Name] = true
+          names = append(names, tag.Name)
+        }
+      }
+    }
+  }
+  if len(names) == 0 {
+    return tpl.GetBaseName()
+  }
+  return tpl.GetBaseName() + " & (" + strings.Join(names, " & ") + ")"
 }
 
 // check_template_inline_all_tags folds a union member template's whole-string

package/native/core/programmers/iterate/json_schema_discriminator.go

@@ -6,17 +6,12 @@ import (
 )
 
 func json_schema_discriminator(metadata *nativemetadata.MetadataSchema) JsonSchema {
-  if metadata.Size() == 0 ||
-    metadata.Size() != len(metadata.Objects) ||
-    json_schema_discriminator_hasLiteral(metadata) {
+  objects := json_schema_discriminator_objects(metadata)
+  if len(objects) == 0 || json_schema_discriminator_hasLiteral(objects) {
     return nil
   }
-  objects := make([]*nativemetadata.MetadataObjectType, 0, len(metadata.Objects))
-  for _, object := range metadata.Objects {
-    objects = append(objects, object.Type)
-  }
   specialized := nativehelpers.UnionPredicator.Object(objects)
-  meet := len(specialized) == len(metadata.Objects)
+  meet := len(specialized) == len(objects)
   if meet {
     keys := map[string]struct{}{}
     for _, item := range specialized {
@@ -47,9 +42,40 @@ func json_schema_discriminator(metadata *nativemetadata.MetadataSchema) JsonSche
   }
 }
 
-func json_schema_discriminator_hasLiteral(metadata *nativemetadata.MetadataSchema) bool {
+// json_schema_discriminator_objects resolves every union member to the object
+// type whose `$ref` that member exports, and returns nil unless all of them do.
+//
+// Declaration syntax decides only which bucket a member lands in: an `interface`
+// member arrives in `Objects`, while a `type` alias of an object literal arrives
+// in `Aliases`. Both export the same `$ref`, so both are eligible to carry a
+// discriminator and eligibility must not depend on the bucket.
+//
+// The alias branch mirrors json_schema_alias's delegation condition exactly, so
+// the resolved object's name stays equal to the `$ref` the member exports, which
+// is what the mapping has to target. An alias naming anything else -- an atomic,
+// a union, or another alias -- exports a `$ref` to the alias itself rather than
+// to an object, so it is not resolvable here.
+func json_schema_discriminator_objects(metadata *nativemetadata.MetadataSchema) []*nativemetadata.MetadataObjectType {
+  if metadata.Size() != len(metadata.Objects)+len(metadata.Aliases) {
+    return nil
+  }
+  objects := make([]*nativemetadata.MetadataObjectType, 0, metadata.Size())
   for _, object := range metadata.Objects {
-    if object.Type.IsLiteral() {
+    objects = append(objects, object.Type)
+  }
+  for _, alias := range metadata.Aliases {
+    value := alias.Type.Value
+    if value == nil || value.Size() != 1 || len(value.Objects) != 1 {
+      return nil
+    }
+    objects = append(objects, value.Objects[0].Type)
+  }
+  return objects
+}
+
+func json_schema_discriminator_hasLiteral(objects []*nativemetadata.MetadataObjectType) bool {
+  for _, object := range objects {
+    if object.IsLiteral() {
       return true
     }
   }