typia 13.0.0-dev.20260430 → 13.0.0-dev.20260502-2

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

@@ -1,11 +1,11 @@
 package functional
 
 import (
-	shimast "github.com/microsoft/typescript-go/shim/ast"
-	nativecontext "github.com/samchon/typia/packages/typia/native/core/context"
-	nativefactories "github.com/samchon/typia/packages/typia/native/core/factories"
-	nativeprogrammers "github.com/samchon/typia/packages/typia/native/core/programmers"
-	functionalinternal "github.com/samchon/typia/packages/typia/native/core/programmers/functional/internal"
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+  nativecontext "github.com/samchon/typia/packages/typia/native/core/context"
+  nativefactories "github.com/samchon/typia/packages/typia/native/core/factories"
+  nativeprogrammers "github.com/samchon/typia/packages/typia/native/core/programmers"
+  functionalinternal "github.com/samchon/typia/packages/typia/native/core/programmers/functional/internal"
 )
 
 type functionAssertReturnProgrammerNamespace struct{}
@@ -13,114 +13,114 @@ type functionAssertReturnProgrammerNamespace struct{}
 var FunctionAssertReturnProgrammer = functionAssertReturnProgrammerNamespace{}
 
 type FunctionAssertReturnProgrammer_IConfig struct {
-	Equals bool
+  Equals bool
 }
 
 type FunctionAssertReturnProgrammer_IProps struct {
-	Context     nativecontext.ITypiaContext
-	Modulo      *shimast.Node
-	Config      FunctionAssertReturnProgrammer_IConfig
-	Expression  *shimast.Node
-	Declaration *shimast.Node
-	Init        *shimast.Node
+  Context     nativecontext.ITypiaContext
+  Modulo      *shimast.Node
+  Config      FunctionAssertReturnProgrammer_IConfig
+  Expression  *shimast.Node
+  Declaration *shimast.Node
+  Init        *shimast.Node
 }
 
 type FunctionAssertReturnProgrammer_IDecomposeProps struct {
-	Context     nativecontext.ITypiaContext
-	Modulo      *shimast.Node
-	Config      FunctionAssertReturnProgrammer_IConfig
-	Expression  *shimast.Node
-	Declaration *shimast.Node
-	Wrapper     string
+  Context     nativecontext.ITypiaContext
+  Modulo      *shimast.Node
+  Config      FunctionAssertReturnProgrammer_IConfig
+  Expression  *shimast.Node
+  Declaration *shimast.Node
+  Wrapper     string
 }
 
 type FunctionAssertReturnProgrammer_IDecomposeOutput struct {
-	Async     bool
-	Functions []*shimast.Node
-	Value     *shimast.Node
+  Async     bool
+  Functions []*shimast.Node
+  Value     *shimast.Node
 }
 
 func (functionAssertReturnProgrammerNamespace) Write(props FunctionAssertReturnProgrammer_IProps) *shimast.Node {
-	wrapper := FunctionalAssertFunctionProgrammer.ErrorFactoryWrapper(struct {
-		Context    nativecontext.ITypiaContext
-		Parameters []*shimast.Node
-		Init       *shimast.Node
-	}{
-		Context:    props.Context,
-		Parameters: functionalIsProgrammer_parameterNodes(props.Declaration),
-		Init:       props.Init,
-	})
-	result := FunctionAssertReturnProgrammer.Decompose(FunctionAssertReturnProgrammer_IDecomposeProps{
-		Context:     props.Context,
-		Modulo:      props.Modulo,
-		Config:      props.Config,
-		Expression:  props.Expression,
-		Declaration: props.Declaration,
-		Wrapper:     wrapper.Name,
-	})
-	statements := []*shimast.Node{wrapper.Variable}
-	statements = append(statements, result.Functions...)
-	statements = append(statements, functionalAssertProgrammer_factory.NewReturnStatement(
-		functionalAssertProgrammer_factory.NewArrowFunction(
-			functionalIsProgrammer_asyncModifiers(result.Async),
-			nil,
-			functionalIsProgrammer_parameters(props.Declaration),
-			functionalAssertProgrammer_returnType(props.Declaration),
-			nil,
-			functionalAssertProgrammer_factory.NewToken(shimast.KindEqualsGreaterThanToken),
-			result.Value,
-		),
-	))
-	return nativefactories.ExpressionFactory.SelfCall(
-		functionalAssertProgrammer_factory.NewBlock(functionalAssertProgrammer_factory.NewNodeList(statements), true),
-	)
+  wrapper := FunctionalAssertFunctionProgrammer.ErrorFactoryWrapper(struct {
+    Context    nativecontext.ITypiaContext
+    Parameters []*shimast.Node
+    Init       *shimast.Node
+  }{
+    Context:    props.Context,
+    Parameters: functionalIsProgrammer_parameterNodes(props.Declaration),
+    Init:       props.Init,
+  })
+  result := FunctionAssertReturnProgrammer.Decompose(FunctionAssertReturnProgrammer_IDecomposeProps{
+    Context:     props.Context,
+    Modulo:      props.Modulo,
+    Config:      props.Config,
+    Expression:  props.Expression,
+    Declaration: props.Declaration,
+    Wrapper:     wrapper.Name,
+  })
+  statements := []*shimast.Node{wrapper.Variable}
+  statements = append(statements, result.Functions...)
+  statements = append(statements, functionalAssertProgrammer_factory.NewReturnStatement(
+    functionalAssertProgrammer_factory.NewArrowFunction(
+      functionalIsProgrammer_asyncModifiers(result.Async),
+      nil,
+      functionalIsProgrammer_parameters(props.Declaration),
+      functionalAssertProgrammer_returnType(props.Declaration),
+      nil,
+      functionalAssertProgrammer_factory.NewToken(shimast.KindEqualsGreaterThanToken),
+      result.Value,
+    ),
+  ))
+  return nativefactories.ExpressionFactory.SelfCall(
+    functionalAssertProgrammer_factory.NewBlock(functionalAssertProgrammer_factory.NewNodeList(statements), true),
+  )
 }
 
 func (functionAssertReturnProgrammerNamespace) Decompose(props FunctionAssertReturnProgrammer_IDecomposeProps) FunctionAssertReturnProgrammer_IDecomposeOutput {
-	output := functionalinternal.FunctionalGeneralProgrammer.GetReturnType(functionalinternal.FunctionalGeneralProgrammer_IProps{
-		Checker:     props.Context.Checker,
-		Declaration: props.Declaration,
-	})
-	caller := functionalAssertProgrammer_factory.NewCallExpression(
-		props.Expression,
-		nil,
-		nil,
-		functionalAssertProgrammer_factory.NewNodeList(functionalIsProgrammer_parameterIdentifiers(props.Declaration)),
-		shimast.NodeFlagsNone,
-	)
-	value := caller
-	if output.Async {
-		value = functionalAssertProgrammer_factory.NewAwaitExpression(caller)
-	}
-	return FunctionAssertReturnProgrammer_IDecomposeOutput{
-		Async: output.Async,
-		Functions: []*shimast.Node{
-			nativefactories.StatementFactory.Constant(nativefactories.StatementFactory_ConstantProps{
-				Name: "__assert_return",
-				Value: nativeprogrammers.AssertProgrammer.Write(nativeprogrammers.AssertProgrammer_IProps{
-					Context: props.Context,
-					Modulo:  props.Modulo,
-					Config: nativeprogrammers.AssertProgrammer_IConfig{
-						Equals: props.Config.Equals,
-						Guard:  false,
-					},
-					Type: output.Type,
-					Init: FunctionalAssertFunctionProgrammer.HookPath(struct {
-						Wrapper  string
-						Replacer string
-					}{
-						Wrapper:  props.Wrapper,
-						Replacer: "$input.return",
-					}),
-				}),
-			}),
-		},
-		Value: functionalAssertProgrammer_factory.NewCallExpression(
-			functionalAssertProgrammer_factory.NewIdentifier("__assert_return"),
-			nil,
-			nil,
-			functionalAssertProgrammer_factory.NewNodeList([]*shimast.Node{value}),
-			shimast.NodeFlagsNone,
-		),
-	}
+  output := functionalinternal.FunctionalGeneralProgrammer.GetReturnType(functionalinternal.FunctionalGeneralProgrammer_IProps{
+    Checker:     props.Context.Checker,
+    Declaration: props.Declaration,
+  })
+  caller := functionalAssertProgrammer_factory.NewCallExpression(
+    props.Expression,
+    nil,
+    nil,
+    functionalAssertProgrammer_factory.NewNodeList(functionalIsProgrammer_parameterIdentifiers(props.Declaration)),
+    shimast.NodeFlagsNone,
+  )
+  value := caller
+  if output.Async {
+    value = functionalAssertProgrammer_factory.NewAwaitExpression(caller)
+  }
+  return FunctionAssertReturnProgrammer_IDecomposeOutput{
+    Async: output.Async,
+    Functions: []*shimast.Node{
+      nativefactories.StatementFactory.Constant(nativefactories.StatementFactory_ConstantProps{
+        Name: "__assert_return",
+        Value: nativeprogrammers.AssertProgrammer.Write(nativeprogrammers.AssertProgrammer_IProps{
+          Context: props.Context,
+          Modulo:  props.Modulo,
+          Config: nativeprogrammers.AssertProgrammer_IConfig{
+            Equals: props.Config.Equals,
+            Guard:  false,
+          },
+          Type: output.Type,
+          Init: FunctionalAssertFunctionProgrammer.HookPath(struct {
+            Wrapper  string
+            Replacer string
+          }{
+            Wrapper:  props.Wrapper,
+            Replacer: "$input.return",
+          }),
+        }),
+      }),
+    },
+    Value: functionalAssertProgrammer_factory.NewCallExpression(
+      functionalAssertProgrammer_factory.NewIdentifier("__assert_return"),
+      nil,
+      nil,
+      functionalAssertProgrammer_factory.NewNodeList([]*shimast.Node{value}),
+      shimast.NodeFlagsNone,
+    ),
+  }
 }

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

@@ -1,9 +1,9 @@
 package functional
 
 import (
-	shimast "github.com/microsoft/typescript-go/shim/ast"
-	nativecontext "github.com/samchon/typia/packages/typia/native/core/context"
-	nativefactories "github.com/samchon/typia/packages/typia/native/core/factories"
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+  nativecontext "github.com/samchon/typia/packages/typia/native/core/context"
+  nativefactories "github.com/samchon/typia/packages/typia/native/core/factories"
 )
 
 type functionalIsFunctionProgrammerNamespace struct{}
@@ -11,90 +11,90 @@ type functionalIsFunctionProgrammerNamespace struct{}
 var FunctionalIsFunctionProgrammer = functionalIsFunctionProgrammerNamespace{}
 
 type FunctionalIsFunctionProgrammer_IConfig struct {
-	Equals bool
+  Equals bool
 }
 
 type FunctionalIsFunctionProgrammer_IProps struct {
-	Context     nativecontext.ITypiaContext
-	Modulo      *shimast.Node
-	Config      FunctionalIsFunctionProgrammer_IConfig
-	Declaration *shimast.Node
-	Expression  *shimast.Node
-	Init        *shimast.Node
+  Context     nativecontext.ITypiaContext
+  Modulo      *shimast.Node
+  Config      FunctionalIsFunctionProgrammer_IConfig
+  Declaration *shimast.Node
+  Expression  *shimast.Node
+  Init        *shimast.Node
 }
 
 func (functionalIsFunctionProgrammerNamespace) Write(props FunctionalIsFunctionProgrammer_IProps) *shimast.Node {
-	p := FunctionalIsParametersProgrammer.Decompose(FunctionalIsParametersProgrammer_IDecomposeProps{
-		Context:     props.Context,
-		Config:      FunctionalIsParametersProgrammer_IConfig{Equals: props.Config.Equals},
-		Modulo:      props.Modulo,
-		Declaration: props.Declaration,
-	})
-	r := FunctionalIsReturnProgrammer.Decompose(FunctionalIsReturnProgrammer_IDecomposeProps{
-		Context:     props.Context,
-		Modulo:      props.Modulo,
-		Config:      FunctionalIsReturnProgrammer_IConfig{Equals: props.Config.Equals},
-		Expression:  props.Expression,
-		Declaration: props.Declaration,
-	})
-	statements := append([]*shimast.Node{}, p.Functions...)
-	statements = append(statements, r.Functions...)
-	body := append([]*shimast.Node{}, p.Statements...)
-	body = append(body, r.Statements...)
-	statements = append(statements, functionalIsProgrammer_factory.NewReturnStatement(
-		functionalIsProgrammer_factory.NewArrowFunction(
-			functionalIsProgrammer_asyncModifiers(r.Async),
-			nil,
-			functionalIsProgrammer_parameters(props.Declaration),
-			FunctionalIsFunctionProgrammer.GetReturnTypeNode(struct {
-				Declaration *shimast.Node
-				Async       bool
-			}{
-				Declaration: props.Declaration,
-				Async:       r.Async,
-			}),
-			nil,
-			functionalIsProgrammer_factory.NewToken(shimast.KindEqualsGreaterThanToken),
-			functionalIsProgrammer_factory.NewBlock(functionalIsProgrammer_factory.NewNodeList(body), true),
-		),
-	))
-	return nativefactories.ExpressionFactory.SelfCall(
-		functionalIsProgrammer_factory.NewBlock(functionalIsProgrammer_factory.NewNodeList(statements), true),
-	)
+  p := FunctionalIsParametersProgrammer.Decompose(FunctionalIsParametersProgrammer_IDecomposeProps{
+    Context:     props.Context,
+    Config:      FunctionalIsParametersProgrammer_IConfig{Equals: props.Config.Equals},
+    Modulo:      props.Modulo,
+    Declaration: props.Declaration,
+  })
+  r := FunctionalIsReturnProgrammer.Decompose(FunctionalIsReturnProgrammer_IDecomposeProps{
+    Context:     props.Context,
+    Modulo:      props.Modulo,
+    Config:      FunctionalIsReturnProgrammer_IConfig{Equals: props.Config.Equals},
+    Expression:  props.Expression,
+    Declaration: props.Declaration,
+  })
+  statements := append([]*shimast.Node{}, p.Functions...)
+  statements = append(statements, r.Functions...)
+  body := append([]*shimast.Node{}, p.Statements...)
+  body = append(body, r.Statements...)
+  statements = append(statements, functionalIsProgrammer_factory.NewReturnStatement(
+    functionalIsProgrammer_factory.NewArrowFunction(
+      functionalIsProgrammer_asyncModifiers(r.Async),
+      nil,
+      functionalIsProgrammer_parameters(props.Declaration),
+      FunctionalIsFunctionProgrammer.GetReturnTypeNode(struct {
+        Declaration *shimast.Node
+        Async       bool
+      }{
+        Declaration: props.Declaration,
+        Async:       r.Async,
+      }),
+      nil,
+      functionalIsProgrammer_factory.NewToken(shimast.KindEqualsGreaterThanToken),
+      functionalIsProgrammer_factory.NewBlock(functionalIsProgrammer_factory.NewNodeList(body), true),
+    ),
+  ))
+  return nativefactories.ExpressionFactory.SelfCall(
+    functionalIsProgrammer_factory.NewBlock(functionalIsProgrammer_factory.NewNodeList(statements), true),
+  )
 }
 
 func (functionalIsFunctionProgrammerNamespace) GetReturnTypeNode(props struct {
-	Declaration *shimast.Node
-	Async       bool
+  Declaration *shimast.Node
+  Async       bool
 }) *shimast.Node {
-	if props.Declaration == nil || props.Declaration.FunctionLikeData() == nil {
-		return nil
-	}
-	typ := props.Declaration.FunctionLikeData().Type
-	if typ == nil {
-		return nil
-	}
-	nullType := functionalIsProgrammer_factory.NewTypeReferenceNode(functionalIsProgrammer_factory.NewIdentifier("null"), nil)
-	if props.Async {
-		var inner *shimast.Node
-		if typ.Kind == shimast.KindTypeReference {
-			ref := typ.AsTypeReferenceNode()
-			if ref.TypeArguments != nil && len(ref.TypeArguments.Nodes) != 0 {
-				inner = ref.TypeArguments.Nodes[0]
-			}
-		}
-		if inner == nil {
-			return nil
-		}
-		return functionalIsProgrammer_factory.NewTypeReferenceNode(
-			functionalIsProgrammer_factory.NewIdentifier("Promise"),
-			functionalIsProgrammer_factory.NewNodeList([]*shimast.Node{
-				functionalIsProgrammer_factory.NewUnionTypeNode(functionalIsProgrammer_factory.NewNodeList([]*shimast.Node{inner, nullType})),
-			}),
-		)
-	}
-	return functionalIsProgrammer_factory.NewUnionTypeNode(functionalIsProgrammer_factory.NewNodeList([]*shimast.Node{
-		typ,
-		nullType,
-	}))
+  if props.Declaration == nil || props.Declaration.FunctionLikeData() == nil {
+    return nil
+  }
+  typ := props.Declaration.FunctionLikeData().Type
+  if typ == nil {
+    return nil
+  }
+  nullType := functionalIsProgrammer_factory.NewTypeReferenceNode(functionalIsProgrammer_factory.NewIdentifier("null"), nil)
+  if props.Async {
+    var inner *shimast.Node
+    if typ.Kind == shimast.KindTypeReference {
+      ref := typ.AsTypeReferenceNode()
+      if ref.TypeArguments != nil && len(ref.TypeArguments.Nodes) != 0 {
+        inner = ref.TypeArguments.Nodes[0]
+      }
+    }
+    if inner == nil {
+      return nil
+    }
+    return functionalIsProgrammer_factory.NewTypeReferenceNode(
+      functionalIsProgrammer_factory.NewIdentifier("Promise"),
+      functionalIsProgrammer_factory.NewNodeList([]*shimast.Node{
+        functionalIsProgrammer_factory.NewUnionTypeNode(functionalIsProgrammer_factory.NewNodeList([]*shimast.Node{inner, nullType})),
+      }),
+    )
+  }
+  return functionalIsProgrammer_factory.NewUnionTypeNode(functionalIsProgrammer_factory.NewNodeList([]*shimast.Node{
+    typ,
+    nullType,
+  }))
 }