typia 15.1.0 → 15.2.0

package/native/core/factories/IdentifierFactory.go

@@ -14,10 +14,8 @@ type identifierFactoryNamespace struct{}
 
 var IdentifierFactory = identifierFactoryNamespace{}
 
-var identifierFactory_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
-
 func (identifierFactoryNamespace) Identifier(name string, emit ...*shimprinter.EmitContext) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(identifierFactory_factory, emit...)
+  f := nativecontext.NodeFactoryOf(emit...)
   if identifierFactory_variable(name) {
     return f.NewIdentifier(name)
   }
@@ -29,7 +27,7 @@ func (identifierFactoryNamespace) Identifier(name string, emit ...*shimprinter.E
 // factories use; a required parameter also makes a forgotten context a compile
 // error rather than a silent metadata gap.
 func (identifierFactoryNamespace) Access(ec *shimprinter.EmitContext, input *shimast.Expression, key string, chain ...bool) *shimast.Node {
-  f := nativecontext.EmitFactory(ec, identifierFactory_factory)
+  f := nativecontext.NodeFactoryOf(ec)
   postfix := IdentifierFactory.Identifier(key, ec)
   optional := len(chain) != 0 && chain[0]
   var questionDot *shimast.QuestionDotToken
@@ -217,7 +215,7 @@ func identifierFactory_surrogate(str string) (rune, int) {
 }
 
 func (identifierFactoryNamespace) Parameter(name any, typeNode *shimast.TypeNode, init *shimast.Node, emit ...*shimprinter.EmitContext) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(identifierFactory_factory, emit...)
+  f := nativecontext.NodeFactoryOf(emit...)
   var binding *shimast.BindingName
   switch v := name.(type) {
   case string:

package/native/core/factories/LiteralFactory.go

@@ -100,10 +100,8 @@ func (obj LiteralFactory_OrderedObject) MarshalJSON() ([]byte, error) {
   return buffer.Bytes(), nil
 }
 
-var literalFactory_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
-
 func (literalFactoryNamespace) Write(input any, emit ...*shimprinter.EmitContext) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(literalFactory_factory, emit...)
+  f := nativecontext.NodeFactoryOf(emit...)
   if input == nil {
     return f.NewKeywordExpression(shimast.KindNullKeyword)
   }
@@ -200,7 +198,7 @@ func literalFactory_fieldName(name string) string {
 }
 
 func literalFactory_writeObject(obj map[string]any, emit ...*shimprinter.EmitContext) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(literalFactory_factory, emit...)
+  f := nativecontext.NodeFactoryOf(emit...)
   keys := make([]string, 0, len(obj))
   for key, value := range obj {
     if literalFactory_isNilLike(value) {
@@ -232,7 +230,7 @@ func literalFactory_writeObject(obj map[string]any, emit ...*shimprinter.EmitCon
 }
 
 func literalFactory_writeOrderedObject(obj LiteralFactory_OrderedObject, emit ...*shimprinter.EmitContext) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(literalFactory_factory, emit...)
+  f := nativecontext.NodeFactoryOf(emit...)
   properties := make([]*shimast.Node, 0, len(obj.Keys))
   for _, key := range obj.Keys {
     value, ok := obj.Values[key]
@@ -329,7 +327,7 @@ func literalFactory_isNilLike(value any) bool {
 }
 
 func literalFactory_writeArray(array []any, emit ...*shimprinter.EmitContext) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(literalFactory_factory, emit...)
+  f := nativecontext.NodeFactoryOf(emit...)
   elements := make([]*shimast.Node, 0, len(array))
   for _, elem := range array {
     elements = append(elements, LiteralFactory.Write(elem, emit...))
@@ -341,7 +339,7 @@ func literalFactory_writeArray(array []any, emit ...*shimprinter.EmitContext) *s
 }
 
 func literalFactory_writeBoolean(value bool, emit ...*shimprinter.EmitContext) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(literalFactory_factory, emit...)
+  f := nativecontext.NodeFactoryOf(emit...)
   if value {
     return f.NewKeywordExpression(shimast.KindTrueKeyword)
   }
@@ -357,5 +355,5 @@ func literalFactory_writeBigint(value any, emit ...*shimprinter.EmitContext) *sh
 }
 
 func literalFactory_writeString(value string, emit ...*shimprinter.EmitContext) *shimast.Node {
-  return nativecontext.EmitFactoryOf(literalFactory_factory, emit...).NewStringLiteral(value, shimast.TokenFlagsNone)
+  return nativecontext.NodeFactoryOf(emit...).NewStringLiteral(value, shimast.TokenFlagsNone)
 }

package/native/core/factories/NumericRangeFactory.go

@@ -10,8 +10,6 @@ type numericRangeFactoryNamespace struct{}
 
 var NumericRangeFactory = numericRangeFactoryNamespace{}
 
-var numericRangeFactory_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
-
 func (numericRangeFactoryNamespace) Number(t string, input *shimast.Expression, emit ...*shimprinter.EmitContext) *shimast.Node {
   switch t {
   case "int32":
@@ -25,7 +23,7 @@ func (numericRangeFactoryNamespace) Number(t string, input *shimast.Expression,
   case "float":
     return numericRangeFactory_between("-3.4028235e38", "3.4028235e38", emit...)(input)
   default:
-    return nativecontext.EmitFactoryOf(numericRangeFactory_factory, emit...).NewKeywordExpression(shimast.KindTrueKeyword)
+    return nativecontext.NodeFactoryOf(emit...).NewKeywordExpression(shimast.KindTrueKeyword)
   }
 }
 
@@ -42,7 +40,7 @@ func (numericRangeFactoryNamespace) Bigint(t string, input *shimast.Expression,
   case "uint64":
     return numericRangeFactory_bigint_between("0", "18446744073709551615", input, emit...)
   default:
-    return nativecontext.EmitFactoryOf(numericRangeFactory_factory, emit...).NewKeywordExpression(shimast.KindTrueKeyword)
+    return nativecontext.NodeFactoryOf(emit...).NewKeywordExpression(shimast.KindTrueKeyword)
   }
 }
 
@@ -83,7 +81,7 @@ func numericRangeFactory_number_uint64(input *shimast.Expression, emit ...*shimp
 }
 
 func numericRangeFactory_integer(input *shimast.Expression, emit ...*shimprinter.EmitContext) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(numericRangeFactory_factory, emit...)
+  f := nativecontext.NodeFactoryOf(emit...)
   return f.NewBinaryExpression(
     nil,
     f.NewCallExpression(
@@ -100,7 +98,7 @@ func numericRangeFactory_integer(input *shimast.Expression, emit ...*shimprinter
 }
 
 func numericRangeFactory_between(x string, y string, emit ...*shimprinter.EmitContext) func(input *shimast.Expression) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(numericRangeFactory_factory, emit...)
+  f := nativecontext.NodeFactoryOf(emit...)
   return func(input *shimast.Expression) *shimast.Node {
     return numericRangeFactory_logical_and(
       f.NewBinaryExpression(
@@ -129,7 +127,7 @@ func numericRangeFactory_between(x string, y string, emit ...*shimprinter.EmitCo
 // rounding that broke the number path -- while the string form parses the digits
 // exactly.
 func numericRangeFactory_bigint_literal(value string, emit ...*shimprinter.EmitContext) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(numericRangeFactory_factory, emit...)
+  f := nativecontext.NodeFactoryOf(emit...)
   return f.NewCallExpression(
     f.NewIdentifier("BigInt"),
     nil,
@@ -144,7 +142,7 @@ func numericRangeFactory_bigint_literal(value string, emit ...*shimprinter.EmitC
 // Both comparisons are inclusive because a bigint represents the true 64-bit
 // bounds exactly, unlike the number path's exclusive approximation.
 func numericRangeFactory_bigint_between(x string, y string, input *shimast.Expression, emit ...*shimprinter.EmitContext) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(numericRangeFactory_factory, emit...)
+  f := nativecontext.NodeFactoryOf(emit...)
   return numericRangeFactory_logical_and(
     f.NewBinaryExpression(
       nil,
@@ -165,11 +163,11 @@ func numericRangeFactory_bigint_between(x string, y string, input *shimast.Expre
 }
 
 func numericRangeFactory_logical_and(x *shimast.Expression, y *shimast.Expression, emit ...*shimprinter.EmitContext) *shimast.Node {
-  return nativecontext.EmitFactoryOf(numericRangeFactory_factory, emit...).NewBinaryExpression(
+  return nativecontext.NodeFactoryOf(emit...).NewBinaryExpression(
     nil,
     x,
     nil,
-    nativecontext.EmitFactoryOf(numericRangeFactory_factory, emit...).NewToken(shimast.KindAmpersandAmpersandToken),
+    nativecontext.NodeFactoryOf(emit...).NewToken(shimast.KindAmpersandAmpersandToken),
     y,
   )
 }

package/native/core/factories/StatementFactory.go

@@ -60,10 +60,8 @@ type StatementFactory_EntryProps struct {
   Value string
 }
 
-var statementFactory_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
-
 func (statementFactoryNamespace) Mut(props StatementFactory_MutProps, emit ...*shimprinter.EmitContext) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(statementFactory_factory, emit...)
+  f := nativecontext.NodeFactoryOf(emit...)
   typeNode := props.Type
   if typeNode == nil && props.Initializer == nil {
     typeNode = TypeFactory.Keyword("any", emit...)
@@ -84,7 +82,7 @@ func (statementFactoryNamespace) Mut(props StatementFactory_MutProps, emit ...*s
 }
 
 func (statementFactoryNamespace) Constant(props StatementFactory_ConstantProps, emit ...*shimprinter.EmitContext) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(statementFactory_factory, emit...)
+  f := nativecontext.NodeFactoryOf(emit...)
   typeNode := props.Type
   if typeNode == nil && props.Value == nil {
     typeNode = TypeFactory.Keyword("any", emit...)
@@ -105,7 +103,7 @@ func (statementFactoryNamespace) Constant(props StatementFactory_ConstantProps,
 }
 
 func (statementFactoryNamespace) Entry(props StatementFactory_EntryProps, emit ...*shimprinter.EmitContext) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(statementFactory_factory, emit...)
+  f := nativecontext.NodeFactoryOf(emit...)
   key := f.NewBindingElement(
     nil,
     nil,
@@ -130,14 +128,14 @@ func (statementFactoryNamespace) Entry(props StatementFactory_EntryProps, emit .
 }
 
 func (statementFactoryNamespace) Transpile(script string, emit ...*shimprinter.EmitContext) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(statementFactory_factory, emit...)
+  f := nativecontext.NodeFactoryOf(emit...)
   return f.NewExpressionStatement(
     f.NewIdentifier(script),
   )
 }
 
 func (statementFactoryNamespace) Block(expression *shimast.Expression, emit ...*shimprinter.EmitContext) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(statementFactory_factory, emit...)
+  f := nativecontext.NodeFactoryOf(emit...)
   return f.NewBlock(
     f.NewNodeList([]*shimast.Node{
       f.NewExpressionStatement(expression),

package/native/core/factories/TemplateFactory.go

@@ -27,10 +27,8 @@ type TemplateFactory_IIterator struct {
   Index int
 }
 
-var templateFactory_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
-
 func (templateFactoryNamespace) Generate(expressions []*shimast.Expression, emit ...*shimprinter.EmitContext) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(templateFactory_factory, emit...)
+  f := nativecontext.NodeFactoryOf(emit...)
   allString := true
   for _, exp := range expressions {
     if !shimast.IsStringLiteral(exp) {

package/native/core/factories/TypeFactory.go

@@ -54,8 +54,6 @@ type TypeFactory_GetFullNameProps struct {
   AliasTypeArguments *bool
 }
 
-var typeFactory_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
-
 func (typeFactoryNamespace) IsFunction(t *shimchecker.Type) bool {
   return TypeFactory.GetFunction(t) != nil
 }
@@ -65,10 +63,10 @@ func (typeFactoryNamespace) GetFunction(t *shimchecker.Type) *shimast.Node {
     return nil
   }
   symbol := t.Symbol()
-  if symbol == nil || len(symbol.Declarations) == 0 {
+  if symbol == nil || len(shimast.SymbolDeclarationsOf(symbol)) == 0 {
     return nil
   }
-  node := symbol.Declarations[0]
+  node := shimast.SymbolDeclarationsOf(symbol)[0]
   if shimast.IsFunctionLike(node) {
     return node
   }
@@ -93,10 +91,10 @@ func (typeFactoryNamespace) GetReturnTypeOfClassMethod(props TypeFactory_GetRetu
     return nil
   }
   symbol := props.Checker.GetPropertyOfType(props.Class, props.Function)
-  if symbol == nil || symbol.ValueDeclaration == nil {
+  if symbol == nil || shimast.SymbolValueDeclarationOf(symbol) == nil {
     return nil
   }
-  functor := props.Checker.GetTypeOfSymbolAtLocation(symbol, symbol.ValueDeclaration)
+  functor := props.Checker.GetTypeOfSymbolAtLocation(symbol, shimast.SymbolValueDeclarationOf(symbol))
   signatures := props.Checker.GetSignaturesOfType(functor, shimchecker.SignatureKindCall)
   if len(signatures) == 0 {
     return nil
@@ -165,10 +163,10 @@ func typeFactory_explore_name(node *shimast.Node, name string) string {
 }
 
 func typeFactory_get_name(symbol *shimast.Symbol) string {
-  if symbol == nil || len(symbol.Declarations) == 0 || symbol.Declarations[0].Parent == nil {
+  if symbol == nil || len(shimast.SymbolDeclarationsOf(symbol)) == 0 || shimast.SymbolDeclarationsOf(symbol)[0].Parent == nil {
     return "__type"
   }
-  return typeFactory_explore_name(symbol.Declarations[0].Parent, symbol.Name)
+  return typeFactory_explore_name(shimast.SymbolDeclarationsOf(symbol)[0].Parent, shimast.SymbolNameOf(symbol))
 }
 
 func typeFactory_get_type_arguments(checker *shimchecker.Checker, t *shimchecker.Type) (output []*shimchecker.Type) {
@@ -182,7 +180,7 @@ func typeFactory_get_type_arguments(checker *shimchecker.Checker, t *shimchecker
 }
 
 func (typeFactoryNamespace) Keyword(t string, emit ...*shimprinter.EmitContext) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(typeFactory_factory, emit...)
+  f := nativecontext.NodeFactoryOf(emit...)
   var kind shimast.KeywordTypeSyntaxKind
   switch t {
   case "void":

package/native/core/factories/ValueFactory.go

@@ -10,18 +10,16 @@ type valueFactoryNamespace struct{}
 
 var ValueFactory = valueFactoryNamespace{}
 
-var valueFactory_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
-
 func (valueFactoryNamespace) NULL(emit ...*shimprinter.EmitContext) *shimast.Node {
-  return nativecontext.EmitFactoryOf(valueFactory_factory, emit...).NewKeywordExpression(shimast.KindNullKeyword)
+  return nativecontext.NodeFactoryOf(emit...).NewKeywordExpression(shimast.KindNullKeyword)
 }
 
 func (valueFactoryNamespace) UNDEFINED(emit ...*shimprinter.EmitContext) *shimast.Node {
-  return nativecontext.EmitFactoryOf(valueFactory_factory, emit...).NewIdentifier("undefined")
+  return nativecontext.NodeFactoryOf(emit...).NewIdentifier("undefined")
 }
 
 func (valueFactoryNamespace) BOOLEAN(value bool, emit ...*shimprinter.EmitContext) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(valueFactory_factory, emit...)
+  f := nativecontext.NodeFactoryOf(emit...)
   if value {
     return f.NewKeywordExpression(shimast.KindTrueKeyword)
   }
@@ -35,9 +33,9 @@ func (valueFactoryNamespace) INPUT(ec *shimprinter.EmitContext, str ...string) *
   if len(str) != 0 {
     name = str[0]
   }
-  return nativecontext.EmitFactory(ec, valueFactory_factory).NewIdentifier(name)
+  return nativecontext.NodeFactoryOf(ec).NewIdentifier(name)
 }
 
 func (valueFactoryNamespace) TYPEOF(input *shimast.Expression, emit ...*shimprinter.EmitContext) *shimast.Node {
-  return nativecontext.EmitFactoryOf(valueFactory_factory, emit...).NewTypeOfExpression(input)
+  return nativecontext.NodeFactoryOf(emit...).NewTypeOfExpression(input)
 }

package/native/core/factories/factory_utility_coverage_test.go

@@ -4,6 +4,7 @@
 package factories
 
 import (
+  nativecontext "github.com/samchon/typia/packages/typia/native/core/context"
   "math/big"
   "os"
   "path/filepath"
@@ -37,7 +38,7 @@ import (
 // @evidence contracts/testing.md#execution-ownership The typia_native_internal Go command (go -C packages/typia/test test -tags typia_native_internal ../native/...) runs this same-package unit Test in process. AST helpers use the node factory; checker-backed cases write a temporary TypeScript fixture, load it through driver.LoadProgram, and close the program. No compiler or JavaScript subprocess is launched.
 func TestFactoryUtilityCoverage(t *testing.T) {
   emit := shimprinter.NewEmitContext()
-  input := expressionFactory_factory.NewIdentifier("input")
+  input := nativecontext.NodeFactoryOf().NewIdentifier("input")
   for _, name := range []string{"int32", "uint32", "int64", "uint64", "float", "double", "unknown"} {
     if NumericRangeFactory.Number(name, input) == nil {
       t.Fatalf("number range %s returned nil", name)
@@ -63,26 +64,26 @@ func TestFactoryUtilityCoverage(t *testing.T) {
   if ExpressionFactory.IsArray(input) == nil ||
     ExpressionFactory.IsObject(ExpressionFactory_IsObjectProps{Input: input, CheckNull: true, CheckArray: true}) == nil ||
     ExpressionFactory.IsInstanceOf("Date", input) == nil ||
-    ExpressionFactory.Coalesce(input, expressionFactory_factory.NewIdentifier("fallback")) == nil {
+    ExpressionFactory.Coalesce(input, nativecontext.NodeFactoryOf().NewIdentifier("fallback")) == nil {
     t.Fatal("basic expression factory branch returned nil")
   }
   if ExpressionFactory.Currying(ExpressionFactory_CurryingProps{
-    Function:  expressionFactory_factory.NewIdentifier("fn"),
+    Function:  nativecontext.NodeFactoryOf().NewIdentifier("fn"),
     Arguments: nil,
   }) == nil {
     t.Fatal("zero-argument currying returned nil")
   }
   if ExpressionFactory.Currying(ExpressionFactory_CurryingProps{
-    Function: expressionFactory_factory.NewIdentifier("fn"),
+    Function: nativecontext.NodeFactoryOf().NewIdentifier("fn"),
     Arguments: []*shimast.Expression{
-      expressionFactory_factory.NewIdentifier("a"),
-      expressionFactory_factory.NewIdentifier("b"),
+      nativecontext.NodeFactoryOf().NewIdentifier("a"),
+      nativecontext.NodeFactoryOf().NewIdentifier("b"),
     },
   }) == nil {
     t.Fatal("multi-argument currying returned nil")
   }
-  call := expressionFactory_factory.NewCallExpression(
-    expressionFactory_factory.NewIdentifier("already"),
+  call := nativecontext.NodeFactoryOf().NewCallExpression(
+    nativecontext.NodeFactoryOf().NewIdentifier("already"),
     nil,
     nil,
     nil,
@@ -101,7 +102,7 @@ func TestFactoryUtilityCoverage(t *testing.T) {
     t.Fatal("identifier escaped text mismatch")
   }
   if ExpressionFactory.GetEscapedText(ExpressionFactory_GetEscapedTextProps{
-    Input: expressionFactory_factory.NewStringLiteral("text", shimast.TokenFlagsNone),
+    Input: nativecontext.NodeFactoryOf().NewStringLiteral("text", shimast.TokenFlagsNone),
   }) != "text" {
     t.Fatal("string escaped text mismatch")
   }
@@ -202,7 +203,7 @@ export let inner!: Outer.Inner;
   if assignedSymbol == nil {
     t.Fatal("holder.assigned symbol was not found")
   }
-  assignedType := prog.Checker.GetTypeOfSymbolAtLocation(assignedSymbol, assignedSymbol.ValueDeclaration)
+  assignedType := prog.Checker.GetTypeOfSymbolAtLocation(assignedSymbol, shimast.SymbolValueDeclarationOf(assignedSymbol))
   assignedDeclaredType := shimchecker.Checker_getTypeOfSymbol(prog.Checker, assignedSymbol)
   if TypeFactory.GetFunction(assignedDeclaredType) == nil && TypeFactory.GetFunction(assignedType) == nil {
     t.Fatal("property assignment initializer should be recognized as function-like")
@@ -212,7 +213,7 @@ export let inner!: Outer.Inner;
   if fieldSymbol == nil {
     t.Fatal("example.field symbol was not found")
   }
-  fieldType := prog.Checker.GetTypeOfSymbolAtLocation(fieldSymbol, fieldSymbol.ValueDeclaration)
+  fieldType := prog.Checker.GetTypeOfSymbolAtLocation(fieldSymbol, shimast.SymbolValueDeclarationOf(fieldSymbol))
   fieldDeclaredType := shimchecker.Checker_getTypeOfSymbol(prog.Checker, fieldSymbol)
   if TypeFactory.GetFunction(fieldDeclaredType) == nil && TypeFactory.GetFunction(fieldType) == nil {
     t.Fatal("property declaration initializer should be recognized as function-like")
@@ -259,7 +260,7 @@ export let inner!: Outer.Inner;
   }
   if IdentifierFactory.Parameter("value", nil, nil) == nil ||
     IdentifierFactory.Parameter(input, TypeFactory.Keyword("string"), nil) == nil ||
-    IdentifierFactory.Parameter(123, nil, expressionFactory_factory.NewToken(shimast.KindQuestionToken)) == nil {
+    IdentifierFactory.Parameter(123, nil, nativecontext.NodeFactoryOf().NewToken(shimast.KindQuestionToken)) == nil {
     t.Fatal("identifier parameter branch returned nil")
   }
 
@@ -309,12 +310,12 @@ export let inner!: Outer.Inner;
     t.Fatal("literal factory branch returned nil")
   }
   if TemplateFactory.Generate([]*shimast.Expression{
-    expressionFactory_factory.NewStringLiteral("a", shimast.TokenFlagsNone),
-    expressionFactory_factory.NewStringLiteral("b", shimast.TokenFlagsNone),
+    nativecontext.NodeFactoryOf().NewStringLiteral("a", shimast.TokenFlagsNone),
+    nativecontext.NodeFactoryOf().NewStringLiteral("b", shimast.TokenFlagsNone),
   }) == nil || TemplateFactory.Generate([]*shimast.Expression{
-    expressionFactory_factory.NewStringLiteral("a", shimast.TokenFlagsNone),
+    nativecontext.NodeFactoryOf().NewStringLiteral("a", shimast.TokenFlagsNone),
     input,
-    expressionFactory_factory.NewStringLiteral("b", shimast.TokenFlagsNone),
+    nativecontext.NodeFactoryOf().NewStringLiteral("b", shimast.TokenFlagsNone),
   }) == nil {
     t.Fatal("template factory branch returned nil")
   }
@@ -872,7 +873,7 @@ export let inner!: Outer.Inner;
 type factoryUtilityImporter struct{}
 
 func (factoryUtilityImporter) Internal(name string) *shimast.Node {
-  return expressionFactory_factory.NewIdentifier(name)
+  return nativecontext.NodeFactoryOf().NewIdentifier(name)
 }
 
 func factoryUtilitySequenceTag(value int) schemametadata.IMetadataTypeTag {
@@ -893,15 +894,15 @@ func factoryUtilityMustPanic(t *testing.T, run func()) {
 }
 
 func (factoryUtilityImporter) Instance(props ExpressionFactory_IInstance) *shimast.Node {
-  return expressionFactory_factory.NewIdentifier(props.Name)
+  return nativecontext.NodeFactoryOf().NewIdentifier(props.Name)
 }
 
 func (factoryUtilityImporter) Namespace(props ExpressionFactory_INamespace) *shimast.Node {
-  return expressionFactory_factory.NewIdentifier(props.Name)
+  return nativecontext.NodeFactoryOf().NewIdentifier(props.Name)
 }
 
 func (factoryUtilityImporter) Default(props ExpressionFactory_IDefault) *shimast.Node {
-  return expressionFactory_factory.NewIdentifier(props.Name)
+  return nativecontext.NodeFactoryOf().NewIdentifier(props.Name)
 }
 
 func factoryUtilityLiteralMetadata(value string) *schemametadata.MetadataSchema {

package/native/core/factories/internal/metadata/MetadataHelper.go

@@ -88,10 +88,10 @@ func metadata_type_symbol_base_name(typ *nativechecker.Type) string {
 }
 
 func metadata_symbol_name(symbol *nativeast.Symbol) string {
-  if symbol == nil || len(symbol.Declarations) == 0 || symbol.Declarations[0].Parent == nil {
+  if symbol == nil || len(nativeast.SymbolDeclarationsOf(symbol)) == 0 || nativeast.SymbolDeclarationsOf(symbol)[0].Parent == nil {
     return "__type"
   }
-  return metadata_explore_symbol_name(symbol.Declarations[0].Parent, symbol.Name)
+  return metadata_explore_symbol_name(nativeast.SymbolDeclarationsOf(symbol)[0].Parent, nativeast.SymbolNameOf(symbol))
 }
 
 func metadata_explore_symbol_name(node *nativeast.Node, name string) string {
@@ -122,10 +122,10 @@ func metadata_get_function_node(checker *nativechecker.Checker, typ *nativecheck
     return nil
   }
   symbol := typ.Symbol()
-  if symbol == nil || len(symbol.Declarations) == 0 {
+  if symbol == nil || len(nativeast.SymbolDeclarationsOf(symbol)) == 0 {
     return nil
   }
-  node := symbol.Declarations[0]
+  node := nativeast.SymbolDeclarationsOf(symbol)[0]
   if nativeast.IsFunctionLike(node) {
     return node
   }
@@ -172,10 +172,10 @@ func metadata_get_return_type_of_class_method(props struct {
     return nil
   }
   symbol := props.Checker.GetPropertyOfType(props.Class, props.Function)
-  if symbol == nil || symbol.ValueDeclaration == nil {
+  if symbol == nil || nativeast.SymbolValueDeclarationOf(symbol) == nil {
     return nil
   }
-  functor := props.Checker.GetTypeOfSymbolAtLocation(symbol, symbol.ValueDeclaration)
+  functor := props.Checker.GetTypeOfSymbolAtLocation(symbol, nativeast.SymbolValueDeclarationOf(symbol))
   signatures := props.Checker.GetSignaturesOfType(functor, nativechecker.SignatureKindCall)
   if len(signatures) == 0 {
     return nil
@@ -271,7 +271,7 @@ func metadata_node_type_js_doc_tags(symbol *nativeast.Symbol) []schemametadata.I
 // other callable object type. See metadata_get_function_node for why the lib
 // `Function` must be treated as a function type (#2178).
 func metadata_is_global_function_interface(symbol *nativeast.Symbol, node *nativeast.Node) bool {
-  if symbol == nil || symbol.Name != "Function" {
+  if symbol == nil || nativeast.SymbolNameOf(symbol) != "Function" {
     return false
   }
   if node == nil || node.Kind != nativeast.KindInterfaceDeclaration {
@@ -341,7 +341,7 @@ func metadata_symbol_from_default_lib(symbol *nativeast.Symbol) bool {
     if src == nil {
       continue
     }
-    return schemametadata.MetadataDefaultLibrary_isFileNamed(src.FileName())
+    return schemametadata.MetadataDefaultLibrary_isFileNamed(string(src.FileName()))
   }
   return false
 }
@@ -415,7 +415,7 @@ func metadata_symbol_has_runtime_provider(checker *nativechecker.Checker, symbol
       return true
     }
   }
-  if checker == nil || symbol.Flags&nativeast.SymbolFlagsValue == 0 {
+  if checker == nil || nativeast.SymbolFlagsOf(symbol)&nativeast.SymbolFlagsValue == 0 {
     return false
   }
   constructor := checker.GetTypeOfSymbol(symbol)
@@ -464,10 +464,10 @@ func metadata_node_in_node_buffer_module(node *nativeast.Node) bool {
 }
 
 func metadata_symbol_is_node_buffer_native_export(symbol *nativeast.Symbol, name string) bool {
-  if symbol == nil || symbol.ValueDeclaration == nil || (name != "Blob" && name != "File") {
+  if symbol == nil || nativeast.SymbolValueDeclarationOf(symbol) == nil || (name != "Blob" && name != "File") {
     return false
   }
-  declaration := symbol.ValueDeclaration
+  declaration := nativeast.SymbolValueDeclarationOf(symbol)
   if declaration.Kind != nativeast.KindClassDeclaration && declaration.Kind != nativeast.KindVariableDeclaration {
     return false
   }
@@ -500,8 +500,8 @@ func metadata_node_declarations(symbol *nativeast.Symbol) []*nativeast.Node {
       output = append(output, node)
     }
   }
-  appendNode(symbol.ValueDeclaration)
-  for _, node := range symbol.Declarations {
+  appendNode(nativeast.SymbolValueDeclarationOf(symbol))
+  for _, node := range nativeast.SymbolDeclarationsOf(symbol) {
     appendNode(node)
   }
   return output

package/native/core/factories/internal/metadata/comment_tags_coverage_test.go

@@ -4,17 +4,13 @@
 package metadata
 
 import (
-  "path/filepath"
   "reflect"
   "testing"
 
-  nativeast "github.com/microsoft/typescript-go/shim/ast"
-  nativecore "github.com/microsoft/typescript-go/shim/core"
-  nativeparser "github.com/microsoft/typescript-go/shim/parser"
   schemametadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
 )
 
-// TestCommentTagsCoverage exercises metadata comment tag application.
+// TestCommentTagsCoverage verifies metadata comment tag application.
 //
 // Comment tags are collected from checker symbols before metadata sorting, so
 // synthetic TypeScript fixtures rarely hit every tag kind deterministically.
@@ -29,7 +25,7 @@ import (
 // @evidence contracts/testing.md#behavioral-verification The comment-tag dispatcher calls a test analyzer on constructed property metadata. Exactly one callback, its property/location inputs, each exact test tag and one propagated error are asserted, and a repeated call must leave the callback count unchanged. Parsed JSDoc presence and nil-helper fallbacks are also checked; the real analyzer's parsing semantics are not exercised here.
 // @evidence contracts/testing.md#independent-expectations Authored callback inputs and marker tags establish the dispatch and once-only contract independently of the dispatcher. The test analyzer deliberately supplies tag/error outputs, so those outputs do not establish real comment-tag parsing; that belongs to factory tests.
 // @evidence contracts/testing.md#distinguishing-cases Every tag bucket, repeated application and parsing are exercised once; this test has few negatives.
-// @evidence contracts/testing.md#execution-ownership The typia_native_internal Go command (go -C packages/typia/test test -tags typia_native_internal ../native/...) runs this same-package Test function in process. The tagged test calls internal helpers with constructed metadata and an installed analyzer; it needs no program load or process.
+// @evidence contracts/testing.md#execution-ownership The typia_native_internal Go command runs this same-package Test in process. Dispatcher cases use constructed metadata and an installed analyzer; the JSDoc case loads one test-owned source through the compiler binder to obtain its real property symbol. Cleanup closes that Program and removes its fixture without launching a compiler or native host subprocess.
 func TestCommentTagsCoverage(t *testing.T) {
   oldAnalyzer := MetadataCommentTagAnalyzer
   calls := 0
@@ -146,9 +142,7 @@ func TestCommentTagsCoverage(t *testing.T) {
     Name:       "NoAnalyzer",
     Properties: []*schemametadata.MetadataProperty{property},
   })})
-  file := nativeparser.ParseSourceFile(
-    nativeast.SourceFileParseOptions{FileName: filepath.ToSlash(filepath.Join(t.TempDir(), "comment.ts"))},
-    `interface Box {
+  program, file := jsDocTestSource(t, `interface Box {
   /**
    * box description
    * @type {string}
@@ -156,14 +150,11 @@ func TestCommentTagsCoverage(t *testing.T) {
    */
   field: string;
 }
-`,
-    nativecore.ScriptKindTS,
-  )
+`)
   member := file.Statements.Nodes[0].AsInterfaceDeclaration().Members.Nodes[0]
-  symbol := &nativeast.Symbol{
-    Name:             "field",
-    ValueDeclaration: member,
-    Declarations:     []*nativeast.Node{member},
+  symbol := program.Checker.GetSymbolAtLocation(member.Name())
+  if symbol == nil {
+    t.Fatal("comment property symbol was not bound")
   }
   if len(metadata_node_js_doc_tags(symbol)) == 0 || metadata_node_description(symbol) == nil {
     t.Fatal("parsed JSDoc tags and description should be discovered")