typia 13.1.1 → 13.2.0

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

@@ -43,10 +43,10 @@ func (functionalIsFunctionProgrammerNamespace) Write(props FunctionalIsFunctionP
   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,
       FunctionalIsFunctionProgrammer.GetReturnTypeNode(struct {
         Context     nativecontext.ITypiaContext
         Declaration *shimast.Node
@@ -56,8 +56,6 @@ func (functionalIsFunctionProgrammerNamespace) Write(props FunctionalIsFunctionP
         Declaration: props.Declaration,
         Async:       r.Async,
       }),
-      nil,
-      f.NewToken(shimast.KindEqualsGreaterThanToken),
       f.NewBlock(f.NewNodeList(body), true),
     ),
   ))

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

@@ -54,10 +54,10 @@ func (functionalIsParametersProgrammerNamespace) Write(props FunctionalIsParamet
   })
   statements := append([]*shimast.Node{}, result.Functions...)
   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,
       FunctionalIsFunctionProgrammer.GetReturnTypeNode(struct {
         Context     nativecontext.ITypiaContext
         Declaration *shimast.Node
@@ -67,17 +67,9 @@ func (functionalIsParametersProgrammerNamespace) Write(props FunctionalIsParamet
         Declaration: props.Declaration,
         Async:       output.Async,
       }),
-      nil,
-      f.NewToken(shimast.KindEqualsGreaterThanToken),
       f.NewBlock(f.NewNodeList(append(
         append([]*shimast.Node{}, result.Statements...),
-        f.NewReturnStatement(f.NewCallExpression(
-          props.Expression,
-          nil,
-          nil,
-          f.NewNodeList(functionalIsProgrammer_parameterIdentifiers(props.Declaration, props.Context.Emit)),
-          shimast.NodeFlagsNone,
-        )),
+        f.NewReturnStatement(functionalIsProgrammer_call(props.Context, props.Expression, props.Declaration)),
       )), true),
     ),
   ))
@@ -139,11 +131,54 @@ func functionalIsProgrammer_parameters(declaration *shimast.Node, emit ...*shimp
 
 func functionalIsProgrammer_parameterNodes(declaration *shimast.Node) []*shimast.Node {
   if params := functionalIsProgrammer_parameters(declaration); params != nil {
-    return params.Nodes
+    output := make([]*shimast.Node, 0, len(params.Nodes))
+    for _, param := range params.Nodes {
+      // TypeScript's explicit `this` parameter declares a receiver type but is
+      // erased at runtime. It is neither validated nor forwarded as an argument.
+      if functionalIsProgrammer_parameterName(param) != "this" {
+        output = append(output, param)
+      }
+    }
+    return output
   }
   return nil
 }
 
+func functionalIsProgrammer_function(
+  context nativecontext.ITypiaContext,
+  declaration *shimast.Node,
+  async bool,
+  returnType *shimast.Node,
+  body *shimast.Node,
+) *shimast.Node {
+  f := nativecontext.EmitFactoryOf(functionalIsProgrammer_factory, context.Emit)
+  return f.NewFunctionExpression(
+    functionalIsProgrammer_asyncModifiers(async, context.Emit),
+    nil,
+    nil,
+    nil,
+    functionalIsProgrammer_parameters(declaration, context.Emit),
+    returnType,
+    nil,
+    body,
+  )
+}
+
+func functionalIsProgrammer_call(context nativecontext.ITypiaContext, expression *shimast.Node, declaration *shimast.Node) *shimast.Node {
+  f := nativecontext.EmitFactoryOf(functionalIsProgrammer_factory, context.Emit)
+  return f.NewCallExpression(
+    nativefactories.IdentifierFactory.Access(context.Emit, f.NewIdentifier("Reflect"), "apply"),
+    nil,
+    nil,
+    f.NewNodeList([]*shimast.Node{
+      expression,
+      f.NewKeywordExpression(shimast.KindThisKeyword),
+      f.NewArrayLiteralExpression(f.NewNodeList(functionalIsProgrammer_parameterIdentifiers(declaration, context.Emit)), false),
+    }),
+    shimast.NodeFlagsNone,
+  )
+}
+
 func functionalIsProgrammer_parameterIdentifiers(declaration *shimast.Node, emit ...*shimprinter.EmitContext) []*shimast.Node {
   f := nativecontext.EmitFactoryOf(functionalIsProgrammer_factory, emit...)
   parameters := functionalIsProgrammer_parameterNodes(declaration)

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/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/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,
   )
 }