typia 13.1.0 → 13.1.19

package/native/core/programmers/functional/FunctionalIsReturnProgrammer.go

@@ -50,10 +50,10 @@ func (functionalIsReturnProgrammerNamespace) Write(props FunctionalIsReturnProgr
   })
   statements := append([]*shimast.Node{}, result.Functions...)
   statements = append(statements, f.NewReturnStatement(
-    f.NewArrowFunction(
-      functionalIsProgrammer_asyncModifiers(result.Async, props.Context.Emit),
-      nil,
-      functionalIsProgrammer_parameters(props.Declaration, props.Context.Emit),
+    functionalIsProgrammer_function(
+      props.Context,
+      props.Declaration,
+      result.Async,
       FunctionalIsFunctionProgrammer.GetReturnTypeNode(struct {
         Context     nativecontext.ITypiaContext
         Declaration *shimast.Node
@@ -63,8 +63,6 @@ func (functionalIsReturnProgrammerNamespace) Write(props FunctionalIsReturnProgr
         Declaration: props.Declaration,
         Async:       result.Async,
       }),
-      nil,
-      f.NewToken(shimast.KindEqualsGreaterThanToken),
       f.NewBlock(f.NewNodeList(result.Statements), true),
     ),
   ))
@@ -80,13 +78,7 @@ func (functionalIsReturnProgrammerNamespace) Decompose(props FunctionalIsReturnP
     Checker:     props.Context.Checker,
     Declaration: props.Declaration,
   })
-  caller := f.NewCallExpression(
-    props.Expression,
-    nil,
-    nil,
-    f.NewNodeList(functionalIsProgrammer_parameterIdentifiers(props.Declaration, props.Context.Emit)),
-    shimast.NodeFlagsNone,
-  )
+  caller := functionalIsProgrammer_call(props.Context, props.Expression, props.Declaration)
   name := functionalIsProgrammer_escapeDuplicate(functionalIsProgrammer_parameterNames(props.Declaration), "result")
   value := caller
   if output.Async {

package/native/core/programmers/functional/FunctionalValidateFunctionProgrammer.go

@@ -45,10 +45,10 @@ func (functionalValidateFunctionProgrammerNamespace) Write(props FunctionalValid
   body := append([]*shimast.Node{}, p.Statements...)
   body = append(body, r.Statements...)
   statements = append(statements, f.NewReturnStatement(
-    f.NewArrowFunction(
-      functionalIsProgrammer_asyncModifiers(r.Async, props.Context.Emit),
-      nil,
-      functionalIsProgrammer_parameters(props.Declaration, props.Context.Emit),
+    functionalIsProgrammer_function(
+      props.Context,
+      props.Declaration,
+      r.Async,
       FunctionalValidateFunctionProgrammer.GetReturnTypeNode(struct {
         Context     nativecontext.ITypiaContext
         Declaration *shimast.Node
@@ -58,8 +58,6 @@ func (functionalValidateFunctionProgrammerNamespace) Write(props FunctionalValid
         Declaration: props.Declaration,
         Async:       r.Async,
       }),
-      nil,
-      f.NewToken(shimast.KindEqualsGreaterThanToken),
       f.NewBlock(f.NewNodeList(body), true),
     ),
   ))

package/native/core/programmers/functional/FunctionalValidateParametersProgrammer.go

@@ -49,13 +49,7 @@ func (functionalValidateParametersProgrammerNamespace) Write(props FunctionalVal
     Declaration: props.Declaration,
   })
   f := nativecontext.EmitFactoryOf(functionalValidateProgrammer_factory, props.Context.Emit)
-  caller := f.NewCallExpression(
-    props.Expression,
-    nil,
-    nil,
-    f.NewNodeList(functionalIsProgrammer_parameterIdentifiers(props.Declaration, props.Context.Emit)),
-    shimast.NodeFlagsNone,
-  )
+  caller := functionalIsProgrammer_call(props.Context, props.Expression, props.Declaration)
   data := caller
   if output.Async {
     data = f.NewAwaitExpression(caller)
@@ -68,10 +62,10 @@ func (functionalValidateParametersProgrammerNamespace) Write(props FunctionalVal
     f.NewPropertyAssignment(nil, nativefactories.IdentifierFactory.Identifier("errors", props.Context.Emit), nil, nil, f.NewArrayLiteralExpression(f.NewNodeList(nil), false)),
   }), true)))
   statements = append(statements, f.NewReturnStatement(
-    f.NewArrowFunction(
-      functionalIsProgrammer_asyncModifiers(output.Async, props.Context.Emit),
-      nil,
-      functionalIsProgrammer_parameters(props.Declaration, props.Context.Emit),
+    functionalIsProgrammer_function(
+      props.Context,
+      props.Declaration,
+      output.Async,
       FunctionalValidateFunctionProgrammer.GetReturnTypeNode(struct {
         Context     nativecontext.ITypiaContext
         Declaration *shimast.Node
@@ -81,8 +75,6 @@ func (functionalValidateParametersProgrammerNamespace) Write(props FunctionalVal
         Declaration: props.Declaration,
         Async:       output.Async,
       }),
-      nil,
-      f.NewToken(shimast.KindEqualsGreaterThanToken),
       f.NewBlock(f.NewNodeList(body), true),
     ),
   ))

package/native/core/programmers/functional/FunctionalValidateReturnProgrammer.go

@@ -50,10 +50,10 @@ func (functionalValidateReturnProgrammerNamespace) Write(props FunctionalValidat
   f := nativecontext.EmitFactoryOf(functionalValidateProgrammer_factory, props.Context.Emit)
   statements := append([]*shimast.Node{}, result.Functions...)
   statements = append(statements, f.NewReturnStatement(
-    f.NewArrowFunction(
-      functionalIsProgrammer_asyncModifiers(result.Async, props.Context.Emit),
-      nil,
-      functionalIsProgrammer_parameters(props.Declaration, props.Context.Emit),
+    functionalIsProgrammer_function(
+      props.Context,
+      props.Declaration,
+      result.Async,
       FunctionalValidateFunctionProgrammer.GetReturnTypeNode(struct {
         Context     nativecontext.ITypiaContext
         Declaration *shimast.Node
@@ -63,8 +63,6 @@ func (functionalValidateReturnProgrammerNamespace) Write(props FunctionalValidat
         Declaration: props.Declaration,
         Async:       result.Async,
       }),
-      nil,
-      f.NewToken(shimast.KindEqualsGreaterThanToken),
       f.NewBlock(f.NewNodeList(result.Statements), true),
     ),
   ))
@@ -80,13 +78,7 @@ func (functionalValidateReturnProgrammerNamespace) Decompose(props FunctionalVal
     Checker:     props.Context.Checker,
     Declaration: props.Declaration,
   })
-  caller := f.NewCallExpression(
-    props.Expression,
-    nil,
-    nil,
-    f.NewNodeList(functionalIsProgrammer_parameterIdentifiers(props.Declaration, props.Context.Emit)),
-    shimast.NodeFlagsNone,
-  )
+  caller := functionalIsProgrammer_call(props.Context, props.Expression, props.Declaration)
   value := caller
   if output.Async {
     value = f.NewAwaitExpression(caller)

package/native/core/programmers/functional/internal/FunctionalGeneralProgrammer.go

@@ -3,6 +3,7 @@ package internal
 import (
   shimast "github.com/microsoft/typescript-go/shim/ast"
   shimchecker "github.com/microsoft/typescript-go/shim/checker"
+  nativeutils "github.com/samchon/typia/packages/typia/native/core/utils"
 )
 
 type functionalGeneralProgrammerNamespace struct{}
@@ -31,23 +32,9 @@ func (functionalGeneralProgrammerNamespace) GetReturnType(props FunctionalGenera
   if t == nil && props.Checker != nil {
     t = props.Checker.GetAnyType()
   }
-  if t != nil {
-    if symbol := t.Symbol(); symbol != nil && symbol.Name == "Promise" {
-      generic := props.Checker.GetTypeArguments(t)
-      if len(generic) == 1 {
-        return FunctionalGeneralProgrammer_IOutput{
-          Type:  generic[0],
-          Async: true,
-        }
-      }
-      return FunctionalGeneralProgrammer_IOutput{
-        Type:  props.Checker.GetAnyType(),
-        Async: false,
-      }
-    }
-  }
+  promised := nativeutils.PromiseTypeFactory.Resolve(props.Checker, t)
   return FunctionalGeneralProgrammer_IOutput{
-    Type:  t,
-    Async: false,
+    Type:  promised.Type,
+    Async: promised.Async,
   }
 }

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

@@ -28,6 +28,13 @@ type CloneJoiner_TupleProps struct {
   Emit     *shimprinter.EmitContext
 }
 
+type CloneJoiner_OptionalElementProps struct {
+  Input *shimast.Expression
+  Value *shimast.Expression
+  Index int
+  Emit  *shimprinter.EmitContext
+}
+
 type CloneJoiner_ArrayProps struct {
   Input *shimast.Expression
   Arrow *shimast.Expression
@@ -190,6 +197,31 @@ func (cloneJoinerNamespace) Tuple(props CloneJoiner_TupleProps) *shimast.Node {
   )
 }
 
+// OptionalTupleElement wraps a cloned tuple element in a presence-gated spread
+// so an omitted optional trailing element is never materialized as a phantom
+// `undefined`. It mirrors `is`, whose length range accepts the shorter tuple:
+// the element is spread in only when `index < input.length`, so `clone(["a"])`
+// for `[string, number?]` stays `["a"]` (length 1) and round-trips under
+// `compare.equals`, while a present optional keeps its value.
+func (cloneJoinerNamespace) OptionalTupleElement(props CloneJoiner_OptionalElementProps) *shimast.Node {
+  f := nativecontext.EmitFactoryOf(cloneJoiner_factory, props.Emit)
+  condition := f.NewBinaryExpression(
+    nil,
+    nativefactories.ExpressionFactory.Number(props.Index, props.Emit),
+    nil,
+    f.NewToken(shimast.KindLessThanToken),
+    nativefactories.IdentifierFactory.Access(props.Emit, props.Input, "length"),
+  )
+  return f.NewSpreadElement(
+    f.NewParenthesizedExpression(nativefactories.ExpressionFactory.Conditional(
+      condition,
+      f.NewArrayLiteralExpression(f.NewNodeList([]*shimast.Node{props.Value}), false),
+      f.NewArrayLiteralExpression(f.NewNodeList(nil), false),
+      props.Emit,
+    )),
+  )
+}
+
 func (cloneJoinerNamespace) Array(props CloneJoiner_ArrayProps) *shimast.Node {
   f := nativecontext.EmitFactoryOf(cloneJoiner_factory, props.Emit)
   return f.NewCallExpression(

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

@@ -13,10 +13,13 @@ type notationJoinerNamespace struct{}
 var NotationJoiner = notationJoinerNamespace{}
 
 type NotationJoiner_ObjectProps struct {
-  Rename  func(str string) string
-  Input   *shimast.Expression
-  Entries []IExpressionEntry
-  Emit    *shimprinter.EmitContext
+  Rename         func(str string) string
+  DynamicRename  func() *shimast.Node
+  DynamicAssign  func() *shimast.Node
+  ThrowCollision func(first string, second string, destination string) *shimast.Node
+  Input          *shimast.Expression
+  Entries        []IExpressionEntry
+  Emit           *shimprinter.EmitContext
 }
 
 type NotationJoiner_TupleProps struct {
@@ -48,13 +51,24 @@ func (notationJoinerNamespace) Object(props NotationJoiner_ObjectProps) *shimast
       dynamic = append(dynamic, entry)
     }
   }
+  destinations := map[string]string{}
+  for _, entry := range regular {
+    source := *entry.Key.GetSoleLiteral()
+    destination := props.Rename(source)
+    if previous, ok := destinations[destination]; ok && previous != source {
+      return props.ThrowCollision(previous, source, destination)
+    }
+    destinations[destination] = source
+  }
 
   properties := make([]*shimast.Node, 0, len(regular))
   for _, entry := range regular {
     str := props.Rename(*entry.Key.GetSoleLiteral())
     properties = append(properties, f.NewPropertyAssignment(
       nil,
-      nativefactories.IdentifierFactory.Identifier(str, props.Emit),
+      f.NewComputedPropertyName(
+        f.NewStringLiteral(str, shimast.TokenFlagsNone),
+      ),
       nil,
       nil,
       entry.Expression,
@@ -70,6 +84,7 @@ func (notationJoinerNamespace) Object(props NotationJoiner_ObjectProps) *shimast
 
   key := f.NewIdentifier("key")
   output := f.NewIdentifier("output")
+  sources := f.NewIdentifier("sources")
   statements := []*shimast.Node{}
   if len(regular) != 0 {
     statements = append(statements, notationJoiner_regular_skip(regular, props.Emit))
@@ -89,12 +104,18 @@ func (notationJoinerNamespace) Object(props NotationJoiner_ObjectProps) *shimast
       f.NewBlock(
         f.NewNodeList([]*shimast.Node{
           f.NewExpressionStatement(
-            f.NewBinaryExpression(
+            f.NewCallExpression(
+              props.DynamicAssign(),
               nil,
-              f.NewElementAccessExpression(output, nil, key, shimast.NodeFlagsNone),
               nil,
-              f.NewToken(shimast.KindEqualsToken),
-              entry.Expression,
+              f.NewNodeList([]*shimast.Node{
+                output,
+                sources,
+                key,
+                entry.Expression,
+                props.DynamicRename(),
+              }),
+              shimast.NodeFlagsNone,
             ),
           ),
           f.NewContinueStatement(nil),
@@ -105,30 +126,67 @@ func (notationJoinerNamespace) Object(props NotationJoiner_ObjectProps) *shimast
     ))
   }
 
-  return f.NewBlock(
-    f.NewNodeList([]*shimast.Node{
-      nativefactories.StatementFactory.Constant(nativefactories.StatementFactory_ConstantProps{
-        Name: "output",
-        Value: f.NewAsExpression(
-          literal,
-          nativefactories.TypeFactory.Keyword("any", props.Emit),
-        ),
-      }, props.Emit),
-      f.NewForInOrOfStatement(
-        shimast.KindForOfStatement,
+  sourceStatements := []*shimast.Node{
+    nativefactories.StatementFactory.Constant(nativefactories.StatementFactory_ConstantProps{
+      Name: "sources",
+      Value: f.NewCallExpression(
+        f.NewIdentifier("Object.create"),
         nil,
-        nativefactories.StatementFactory.Entry(nativefactories.StatementFactory_EntryProps{Key: "key", Value: "value"}, props.Emit),
-        f.NewCallExpression(
-          f.NewIdentifier("Object.entries"),
-          nil,
+        nil,
+        f.NewNodeList([]*shimast.Node{
+          f.NewKeywordExpression(shimast.KindNullKeyword),
+        }),
+        shimast.NodeFlagsNone,
+      ),
+    }, props.Emit),
+  }
+  for _, entry := range regular {
+    source := *entry.Key.GetSoleLiteral()
+    destination := props.Rename(source)
+    sourceStatements = append(sourceStatements, f.NewExpressionStatement(
+      f.NewBinaryExpression(
+        nil,
+        f.NewElementAccessExpression(
+          sources,
           nil,
-          f.NewNodeList([]*shimast.Node{props.Input}),
+          f.NewStringLiteral(destination, shimast.TokenFlagsNone),
           shimast.NodeFlagsNone,
         ),
-        f.NewBlock(f.NewNodeList(statements), false),
+        nil,
+        f.NewToken(shimast.KindEqualsToken),
+        f.NewStringLiteral(source, shimast.TokenFlagsNone),
+      ),
+    ))
+  }
+
+  body := []*shimast.Node{
+    nativefactories.StatementFactory.Constant(nativefactories.StatementFactory_ConstantProps{
+      Name: "output",
+      Value: f.NewAsExpression(
+        literal,
+        nativefactories.TypeFactory.Keyword("any", props.Emit),
       ),
-      f.NewReturnStatement(output),
-    }),
+    }, props.Emit),
+  }
+  body = append(body, sourceStatements...)
+  body = append(body,
+    f.NewForInOrOfStatement(
+      shimast.KindForOfStatement,
+      nil,
+      nativefactories.StatementFactory.Entry(nativefactories.StatementFactory_EntryProps{Key: "key", Value: "value"}, props.Emit),
+      f.NewCallExpression(
+        f.NewIdentifier("Object.entries"),
+        nil,
+        nil,
+        f.NewNodeList([]*shimast.Node{props.Input}),
+        shimast.NodeFlagsNone,
+      ),
+      f.NewBlock(f.NewNodeList(statements), false),
+    ),
+    f.NewReturnStatement(output),
+  )
+  return f.NewBlock(
+    f.NewNodeList(body),
     false,
   )
 }

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

@@ -3,6 +3,7 @@ package helpers
 import (
   "encoding/json"
   "sort"
+  "strings"
 
   shimast "github.com/microsoft/typescript-go/shim/ast"
   shimprinter "github.com/microsoft/typescript-go/shim/printer"
@@ -143,8 +144,13 @@ func stringifyJoiner_regular_properties(regular []IExpressionEntry, dynamic []IE
     if err != nil {
       encoded = []byte("\"" + *key + "\"")
     }
+    // encoded is escaped for a JSON string, but the literal becomes a part of a
+    // template literal (TemplateFactory.Generate). The two contexts disagree, so
+    // 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.
     base := []*shimast.Node{
-      f.NewStringLiteral(string(encoded)+":", shimast.TokenFlagsNone),
+      f.NewStringLiteral(stringifyJoiner_escape_template(string(encoded))+":", shimast.TokenFlagsNone),
       entry.Expression,
     }
     if index != len(regular)-1 || len(dynamic) != 0 {
@@ -397,6 +403,31 @@ func stringifyJoiner_all_string_literals(elements []*shimast.Expression) bool {
   return true
 }
 
+// stringifyJoiner_escape_template escapes an already-JSON-encoded key so that,
+// spliced verbatim into a backtick template literal, it reproduces the exact
+// JSON bytes at runtime. It doubles every backslash (so JSON escapes such as
+// `\"`, `\\`, `\t`, `<` survive), escapes a backtick (which would close the
+// template), and escapes the `$` of a `${` pair (which would start a live
+// interpolation). A `$` not followed by `{` and every ordinary character stay
+// byte-identical, so keys that need none of these are unchanged.
+func stringifyJoiner_escape_template(text string) string {
+  var builder strings.Builder
+  builder.Grow(len(text))
+  for i := 0; i < len(text); i++ {
+    switch c := text[i]; {
+    case c == '\\':
+      builder.WriteString("\\\\")
+    case c == '`':
+      builder.WriteString("\\`")
+    case c == '$' && i+1 < len(text) && text[i+1] == '{':
+      builder.WriteString("\\$")
+    default:
+      builder.WriteByte(c)
+    }
+  }
+  return builder.String()
+}
+
 func joinStrings(values []string, sep string) string {
   if len(values) == 0 {
     return ""