typia 13.1.19 → 13.2.0

package/native/core/programmers/compare/CompareEqualProgrammer.go

@@ -12,6 +12,7 @@ import (
   nativefactories "github.com/samchon/typia/packages/typia/native/core/factories"
   nativehelpers "github.com/samchon/typia/packages/typia/native/core/programmers/helpers"
   nativeinternal "github.com/samchon/typia/packages/typia/native/core/programmers/internal"
+  nativeiterate "github.com/samchon/typia/packages/typia/native/core/programmers/iterate"
   schemametadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
 )
 
@@ -31,9 +32,10 @@ type CompareEqualProgrammer_IProps struct {
 }
 
 type compareEqualProgrammerGenerator struct {
-  Config    CompareEqualProgrammer_IConfig
-  Recursive bool
-  Counter   int
+  Config     CompareEqualProgrammer_IConfig
+  Functional bool
+  Recursive  bool
+  Counter    int
   // Member-resolution checkers (`_ui<index>`) emitted on demand for the object
   // unions that need the is-match ladder, keyed by the object's collection index.
   Matchers     []string
@@ -76,6 +78,7 @@ func (compareEqualProgrammerNamespace) Write(props CompareEqualProgrammer_IProps
 
   generator := &compareEqualProgrammerGenerator{
     Config:       props.Config,
+    Functional:   nativehelpers.OptionPredicator.Functional(props.Context.Options),
     Recursive:    nativeinternal.FeatureProgrammer.CollectionRecursive(collection),
     MatcherIndex: map[int]bool{},
   }
@@ -307,9 +310,8 @@ func (g *compareEqualProgrammerGenerator) objectCall(object *schemametadata.Meta
   return fmt.Sprintf("_eo%d(%s, %s)", object.Index, g.wrap(x), g.wrap(y))
 }
 
-// objectFlatBranch renders one member of an object union as a guarded member
-// comparator (the pre-discrimination form). It is used for a single-object
-// "union" and as the fallback for a union no supported predicate can split.
+// objectFlatBranch renders a single object member as a guarded comparator. A
+// multi-object union always uses objectUnion's member dispatch instead.
 func (g *compareEqualProgrammerGenerator) objectFlatBranch(object *schemametadata.MetadataObjectType, natives []*schemametadata.MetadataNative, x string, y string) string {
   // Guard the object branch against the sibling native instances. `_eo` admits
   // any `typeof === "object" && !Array.isArray` value, so a native (a Date is
@@ -439,16 +441,15 @@ func (g *compareEqualProgrammerGenerator) matchCall(object *schemametadata.Metad
 // may be absent), and every extra key a dynamic index signature declares must
 // hold a value of the signature's type. It mirrors the `_io` checkers `is`
 // emits, at the abstraction level the rest of this programmer works at — shape
-// and typeof, not the value constraints (`typia.tags.*`, template patterns)
-// `compare` deliberately ignores.
+// and typeof, plus structural template patterns. Function-valued properties
+// participate in this routing check whenever `is` makes them meaningful; they
+// remain excluded from object value comparison after a member is selected. It
+// deliberately ignores `typia.tags.*` constraints.
 func (g *compareEqualProgrammerGenerator) matchObject(object *schemametadata.MetadataObjectType, v string) string {
   checks := []string{}
   regularKeys := []string{}
   dynamic := []*schemametadata.MetadataProperty{}
   for _, property := range object.Properties {
-    if compareProgrammer_isMethod(property) {
-      continue // methods carry no comparable data, so they do not route either
-    }
     if sole := property.Key.GetSoleLiteral(); sole != nil {
       regularKeys = append(regularKeys, *sole)
       checks = append(checks, g.matchSlot(property.Value, g.property(v, *sole)))
@@ -504,9 +505,9 @@ func (g *compareEqualProgrammerGenerator) match(metadata *schemametadata.Metadat
     branches = append(branches, g.typeof(v, atomic.Type))
   }
   if len(metadata.Templates) != 0 {
-    branches = append(branches, g.typeof(v, "string"))
+    branches = append(branches, g.and(g.typeof(v, "string"), g.template(metadata.Templates, v)))
   }
-  if len(metadata.Functions) != 0 {
+  if len(metadata.Functions) != 0 && (g.Functional || metadata.Size() != 1) {
     branches = append(branches, g.typeof(v, "function"))
   }
   for _, native := range metadata.Natives {
@@ -767,6 +768,19 @@ func (g *compareEqualProgrammerGenerator) dynamicKey(metadata *schemametadata.Me
   return g.or(checks...)
 }
 
+// template renders the structural membership test shared with the authoritative
+// runtime template checker. Compare still ignores typia tag predicates when it
+// compares values, but it must retain the template-literal domain while routing
+// an object union to a declared member.
+func (g *compareEqualProgrammerGenerator) template(templates []*schemametadata.MetadataTemplate, input string) string {
+  checks := make([]string, 0, len(templates))
+  for _, template := range templates {
+    pattern := nativeiterate.TemplateRuntimePattern(template.Row)
+    checks = append(checks, fmt.Sprintf("RegExp(%s).test(%s)", strconv.Quote(pattern), g.wrap(input)))
+  }
+  return g.or(checks...)
+}
+
 func (g *compareEqualProgrammerGenerator) visit(kind string, index int) string {
   slot := fmt.Sprintf("_vctx.%s%d", kind, index)
   return fmt.Sprintf("const _map = %s || (%s = new WeakMap()); let _set = _map.get(x); if (_set && _set.has(y)) return true; if (!_set) _map.set(x, (_set = new WeakSet())); _set.add(y);", slot, slot)

package/native/core/programmers/helpers/FunctionProgrammer.go

@@ -15,12 +15,11 @@ type FunctionProgrammer struct {
   unions_        map[string]*functionProgrammer_union
   unionOrder_    []string
   variables_     map[string]*shimast.Node
-  variableKeys_   map[string]string
+  variableKeys_  map[string]string
   variableOrder_ []string
-  nameIndexes_    map[string]int
-  reservedNames_  map[string]bool
+  nameIndexes_   map[string]int
+  reservedNames_ map[string]bool
   sequence_      int
-  disableDeclare bool
   // visited_ turns on per-invocation visit tracking: set after metadata
   // analysis when the type graph carries a recursive component, so generated
   // functions thread a `_vctx` context and recursive ones guard against
@@ -54,10 +53,10 @@ func NewFunctionProgrammer(method string, emit ...*shimprinter.EmitContext) *Fun
     unions_:        map[string]*functionProgrammer_union{},
     unionOrder_:    []string{},
     variables_:     map[string]*shimast.Node{},
-    variableKeys_:   map[string]string{},
+    variableKeys_:  map[string]string{},
     variableOrder_: []string{},
-    nameIndexes_:    map[string]int{},
-    reservedNames_:  map[string]bool{},
+    nameIndexes_:   map[string]int{},
+    reservedNames_: map[string]bool{},
   }
   if len(emit) != 0 {
     p.emit_ = emit[0]
@@ -93,9 +92,6 @@ func (p *FunctionProgrammer) HasLocal(name string) bool {
 }
 
 func (p *FunctionProgrammer) Declare(includeUnions ...bool) []*shimast.Node {
-  if p.disableDeclare {
-    return []*shimast.Node{}
-  }
   output := []*shimast.Node{}
   for _, name := range p.variableOrder_ {
     value := p.variables_[name]
@@ -121,9 +117,6 @@ func (p *FunctionProgrammer) Declare(includeUnions ...bool) []*shimast.Node {
 }
 
 func (p *FunctionProgrammer) DeclareUnions() []*shimast.Node {
-  if p.disableDeclare {
-    return []*shimast.Node{}
-  }
   output := []*shimast.Node{}
   for _, key := range p.unionOrder_ {
     tuple := p.unions_[key]

package/native/core/programmers/helpers/StringifyJoinder.go

@@ -2,7 +2,6 @@ package helpers
 
 import (
   "encoding/json"
-  "sort"
   "strings"
 
   shimast "github.com/microsoft/typescript-go/shim/ast"
@@ -22,9 +21,10 @@ type StringifyJoiner_ObjectProps struct {
 }
 
 type StringifyJoiner_ArrayProps struct {
-  Input *shimast.Expression
-  Arrow *shimast.Expression
-  Emit  *shimprinter.EmitContext
+  Context nativecontext.ITypiaContext
+  Input   *shimast.Expression
+  Arrow   *shimast.Expression
+  Emit    *shimprinter.EmitContext
 }
 
 type StringifyJoiner_TupleProps struct {
@@ -49,17 +49,22 @@ func (stringifyJoinerNamespace) Object(props StringifyJoiner_ObjectProps) *shima
       dynamic = append(dynamic, entry)
     }
   }
-  expressions := stringifyJoiner_regular_properties(regular, dynamic, props.Context.Emit)
+  expressions := stringifyJoiner_regular_properties(props.Context, regular, dynamic, props.Context.Emit)
   if len(dynamic) != 0 {
     keys := make([]string, 0, len(regular))
     for _, entry := range regular {
       keys = append(keys, *entry.Key.GetSoleLiteral())
     }
-    expressions = append(expressions, stringifyJoiner_dynamic_properties(dynamic, keys, props.Context.Emit))
+    expressions = append(expressions, stringifyJoiner_dynamic_properties(props.Context, dynamic, keys, props.Context.Emit))
   }
 
+  // The tail helper removes the separator left behind when the last written
+  // member drops out at runtime, so it may only be skipped when the last regular
+  // member cannot drop. Required is not the same as cannot-drop: a required
+  // `any` member is omitted whenever its value serializes to `undefined`, which
+  // without this produced a trailing comma before `}` (#2253).
   filtered := expressions
-  if !((len(regular) != 0 && regular[len(regular)-1].Meta.IsRequired() && len(dynamic) == 0) ||
+  if !((len(regular) != 0 && !stringifyJoiner_entry_omittable(regular[len(regular)-1]) && len(dynamic) == 0) ||
     (len(regular) == 0 && len(dynamic) != 0)) {
     filtered = []*shimast.Node{
       f.NewCallExpression(
@@ -79,27 +84,26 @@ func (stringifyJoinerNamespace) Object(props StringifyJoiner_ObjectProps) *shima
   return nativefactories.TemplateFactory.Generate(output, props.Context.Emit)
 }
 
+// Array serializes elements through the `_jsonStringifyArray` helper rather than
+// `input.map(...).join(",")`.
+//
+// `map` never visits a hole and leaves one behind, and `join` renders both a
+// hole and a mapped `undefined` as empty text, so the two cases ECMAScript's
+// SerializeJSONArray answers with `null` were emitted as nothing at all: a
+// sparse array produced the malformed text `[,1]`, and an element serializing to
+// `undefined` — a function, a symbol, or a `toJSON` returning nothing in an
+// `any` or `unknown` slot — silently collapsed its position. A hole exists at
+// runtime whatever the element type declares, so this is not confined to `any`
+// (#2253).
 func (stringifyJoinerNamespace) Array(props StringifyJoiner_ArrayProps) *shimast.Node {
   f := nativecontext.EmitFactoryOf(stringifyJoiner_factory, props.Emit)
   return nativefactories.TemplateFactory.Generate([]*shimast.Node{
     f.NewStringLiteral("[", shimast.TokenFlagsNone),
     f.NewCallExpression(
-      nativefactories.IdentifierFactory.Access(
-        nil,
-        f.NewCallExpression(
-          nativefactories.IdentifierFactory.Access(nil, props.Input, "map"),
-          nil,
-          nil,
-          f.NewNodeList([]*shimast.Node{props.Arrow}),
-          shimast.NodeFlagsNone,
-        ),
-        "join",
-      ),
+      stringifyJoiner_internal(props.Context, "jsonStringifyArray"),
       nil,
       nil,
-      f.NewNodeList([]*shimast.Node{
-        f.NewStringLiteral(",", shimast.TokenFlagsNone),
-      }),
+      f.NewNodeList([]*shimast.Node{props.Input, props.Arrow}),
       shimast.NodeFlagsNone,
     ),
     f.NewStringLiteral("]", shimast.TokenFlagsNone),
@@ -132,12 +136,17 @@ func (stringifyJoinerNamespace) Tuple(props StringifyJoiner_TupleProps) *shimast
   return nativefactories.TemplateFactory.Generate(expressions, props.Emit)
 }
 
-func stringifyJoiner_regular_properties(regular []IExpressionEntry, dynamic []IExpressionEntry, emit ...*shimprinter.EmitContext) []*shimast.Node {
+func stringifyJoiner_regular_properties(context nativecontext.ITypiaContext, regular []IExpressionEntry, dynamic []IExpressionEntry, emit ...*shimprinter.EmitContext) []*shimast.Node {
   f := nativecontext.EmitFactoryOf(stringifyJoiner_factory, emit...)
   output := []*shimast.Node{}
-  sort.Slice(regular, func(i int, j int) bool {
-    return stringifyJoiner_sequence(regular[i].Meta) < stringifyJoiner_sequence(regular[j].Meta)
-  })
+  // Members keep their declaration order, which is what the guide promises and
+  // what `JSON.stringify` produces for a value assigned in that order. They used
+  // to be sorted so every omissible member sat ahead of the required ones,
+  // because the separator is appended to every entry but the last and a last
+  // member that drops at runtime would leave a trailing comma. The caller
+  // already repairs exactly that with `_jsonStringifyTail`, whose condition
+  // reads the last member and now sees the declared one, so the ordering
+  // constraint the sort existed for no longer applies (#2295).
   for index, entry := range regular {
     key := entry.Key.GetSoleLiteral()
     encoded, err := json.Marshal(*key)
@@ -149,19 +158,44 @@ func stringifyJoiner_regular_properties(regular []IExpressionEntry, dynamic []IE
     // re-escape the JSON bytes for the template-literal context: otherwise `\"`
     // decays to `"`, `\\` to `\`, a control-char escape's backslash is dropped, a
     // raw backtick closes the template, and `${` starts a live interpolation.
+    separator := ""
+    if index != len(regular)-1 || len(dynamic) != 0 {
+      separator = ","
+    }
     base := []*shimast.Node{
       f.NewStringLiteral(stringifyJoiner_escape_template(string(encoded))+":", shimast.TokenFlagsNone),
       entry.Expression,
     }
-    if index != len(regular)-1 || len(dynamic) != 0 {
-      base = append(base, f.NewStringLiteral(",", shimast.TokenFlagsNone))
+    if separator != "" {
+      base = append(base, f.NewStringLiteral(separator, shimast.TokenFlagsNone))
     }
     empty := (!entry.Meta.IsRequired() && !entry.Meta.Nullable && entry.Meta.Size() == 0) ||
       (len(entry.Meta.Functions) != 0 && !entry.Meta.Nullable && entry.Meta.Size() == 1)
     if empty {
       continue
     }
-    if !entry.Meta.IsRequired() || len(entry.Meta.Functions) != 0 || entry.Meta.Any {
+    if stringifyJoiner_result_undefinable(entry.Meta) {
+      // An `any` or `unknown` member is serialized by JSON.stringify, which
+      // answers `undefined` for a function, a symbol, and a `toJSON` returning
+      // nothing while the value itself is present. Only the serialized result
+      // distinguishes those from a value that has text, so the member is written
+      // through the helper that reads that result — once, because a `toJSON` may
+      // answer differently on a second call (#2253). The input tests below stay
+      // for members whose serializer must not run on a missing value at all.
+      output = append(output, f.NewCallExpression(
+        stringifyJoiner_internal(context, "jsonStringifyProperty"),
+        nil,
+        nil,
+        f.NewNodeList([]*shimast.Node{
+          f.NewStringLiteral(string(encoded)+":", shimast.TokenFlagsNone),
+          entry.Expression,
+          f.NewStringLiteral(separator, shimast.TokenFlagsNone),
+        }),
+        shimast.NodeFlagsNone,
+      ))
+      continue
+    }
+    if !entry.Meta.IsRequired() || len(entry.Meta.Functions) != 0 {
       output = append(output, nativefactories.ExpressionFactory.Conditional(
         stringifyJoiner_regular_condition(entry, emit...),
         f.NewStringLiteral("", shimast.TokenFlagsNone),
@@ -175,6 +209,39 @@ func stringifyJoiner_regular_properties(regular []IExpressionEntry, dynamic []IE
   return output
 }
 
+// stringifyJoiner_entry_omittable reports whether a member can be absent from
+// the emitted object at runtime, which is exactly the set of members that are
+// written through a conditional or through the property helper.
+func stringifyJoiner_entry_omittable(entry IExpressionEntry) bool {
+  return !entry.Meta.IsRequired() || len(entry.Meta.Functions) != 0 ||
+    stringifyJoiner_result_undefinable(entry.Meta)
+}
+
+// stringifyJoiner_result_undefinable reports whether a value that is present can
+// still serialize to nothing, which is the case an input test cannot see.
+//
+// `any` and `unknown` are serialized by JSON.stringify, which answers
+// `undefined` for a function, a symbol, and a `toJSON` returning nothing. A
+// declared `toJSON` is the same case without `any`: the member's text is its
+// return value, so a return type that admits `undefined` admits a member with no
+// text (#2253).
+// StringifyJoiner_ResultUndefinable exposes the same question to the element
+// positions the joiner does not build itself, so a tuple slot and an object
+// member classify a value identically.
+func StringifyJoiner_ResultUndefinable(meta *nativemetadata.MetadataSchema) bool {
+  return stringifyJoiner_result_undefinable(meta)
+}
+
+func stringifyJoiner_result_undefinable(meta *nativemetadata.MetadataSchema) bool {
+  if meta == nil {
+    return false
+  }
+  if meta.Any {
+    return true
+  }
+  return meta.Escaped != nil && meta.Escaped.Returns != nil && !meta.Escaped.Returns.IsRequired()
+}
+
 func stringifyJoiner_regular_condition(entry IExpressionEntry, emit ...*shimprinter.EmitContext) *shimast.Node {
   f := nativecontext.EmitFactoryOf(stringifyJoiner_factory, emit...)
   conditions := []*shimast.Node{}
@@ -199,7 +266,7 @@ func stringifyJoiner_regular_condition(entry IExpressionEntry, emit ...*shimprin
   return stringifyJoiner_reduce(conditions, shimast.KindBarBarToken, emit...)
 }
 
-func stringifyJoiner_dynamic_properties(dynamic []IExpressionEntry, regular []string, emit ...*shimprinter.EmitContext) *shimast.Node {
+func stringifyJoiner_dynamic_properties(context nativecontext.ITypiaContext, dynamic []IExpressionEntry, regular []string, emit ...*shimprinter.EmitContext) *shimast.Node {
   f := nativecontext.EmitFactoryOf(stringifyJoiner_factory, emit...)
   statements := []*shimast.Node{
     f.NewIfStatement(
@@ -298,7 +365,7 @@ func stringifyJoiner_dynamic_properties(dynamic []IExpressionEntry, regular []st
   }
   simple := len(dynamic) == 1 && dynamic[0].Key.Size() == 1 && len(dynamic[0].Key.Atomics) != 0 && dynamic[0].Key.Atomics[0].Type == "string"
   if simple {
-    statements = append(statements, stringifyJoiner_stringify(dynamic[0], emit...))
+    statements = append(statements, stringifyJoiner_stringify(context, dynamic[0], emit...))
     return output()
   }
   for _, entry := range dynamic {
@@ -313,7 +380,7 @@ func stringifyJoiner_dynamic_properties(dynamic []IExpressionEntry, regular []st
         f.NewNodeList([]*shimast.Node{f.NewIdentifier("key")}),
         shimast.NodeFlagsNone,
       ),
-      stringifyJoiner_stringify(entry, emit...),
+      stringifyJoiner_stringify(context, entry, emit...),
       nil,
     ))
   }
@@ -321,20 +388,39 @@ func stringifyJoiner_dynamic_properties(dynamic []IExpressionEntry, regular []st
   return output()
 }
 
-func stringifyJoiner_stringify(entry IExpressionEntry, emit ...*shimprinter.EmitContext) *shimast.Node {
+func stringifyJoiner_stringify(context nativecontext.ITypiaContext, entry IExpressionEntry, emit ...*shimprinter.EmitContext) *shimast.Node {
   f := nativecontext.EmitFactoryOf(stringifyJoiner_factory, emit...)
+  head := nativefactories.TemplateFactory.Generate([]*shimast.Node{
+    f.NewCallExpression(
+      f.NewIdentifier("JSON.stringify"),
+      nil,
+      f.NewNodeList(nil),
+      f.NewNodeList([]*shimast.Node{f.NewIdentifier("key")}),
+      shimast.NodeFlagsNone,
+    ),
+    f.NewStringLiteral(":", shimast.TokenFlagsNone),
+  }, emit...)
+  if entry.Meta.Any {
+    // An index-signature member takes the same contextual decision a static one
+    // takes: `any` and `unknown` values are serialized by JSON.stringify, which
+    // answers `undefined` for a present function, symbol, or empty `toJSON`.
+    // Returning the empty string hands the surrounding filter the same sentinel
+    // it already uses for a missing value, so the member and its separator drop
+    // together instead of rendering the literal `undefined` (#2253).
+    return f.NewReturnStatement(f.NewCallExpression(
+      stringifyJoiner_internal(context, "jsonStringifyProperty"),
+      nil,
+      nil,
+      f.NewNodeList([]*shimast.Node{
+        head,
+        entry.Expression,
+        f.NewStringLiteral("", shimast.TokenFlagsNone),
+      }),
+      shimast.NodeFlagsNone,
+    ))
+  }
   return f.NewReturnStatement(
-    nativefactories.TemplateFactory.Generate([]*shimast.Node{
-      f.NewCallExpression(
-        f.NewIdentifier("JSON.stringify"),
-        nil,
-        f.NewNodeList(nil),
-        f.NewNodeList([]*shimast.Node{f.NewIdentifier("key")}),
-        shimast.NodeFlagsNone,
-      ),
-      f.NewStringLiteral(":", shimast.TokenFlagsNone),
-      entry.Expression,
-    }, emit...),
+    nativefactories.TemplateFactory.Generate([]*shimast.Node{head, entry.Expression}, emit...),
   )
 }
 
@@ -380,13 +466,6 @@ func stringifyJoiner_reduce(expressions []*shimast.Node, operator shimast.Kind,
   return output
 }
 
-func stringifyJoiner_sequence(meta *nativemetadata.MetadataSchema) int {
-  if meta.Any || !meta.IsRequired() || len(meta.Functions) != 0 {
-    return 0
-  }
-  return 1
-}
-
 func stringifyJoiner_internal(context nativecontext.ITypiaContext, name string) *shimast.Node {
   if importer := context.Importer; importer != nil {
     return importer.Internal(name)