typia 15.1.0 → 15.2.0

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

@@ -44,8 +44,8 @@ func Emplace_metadata_object(props IMetadataIteratorProps) *schemametadata.Metad
     // Capture the first symbol declaration's source file when locatable so
     // plain.classify can value-import a cross-module class it reconstructs.
     // Additive: other features ignore obj.Source.
-    if sym := props.Type.Symbol(); sym != nil && len(sym.Declarations) != 0 {
-      decl := sym.Declarations[0]
+    if sym := props.Type.Symbol(); sym != nil && len(nativeast.SymbolDeclarationsOf(sym)) != 0 {
+      decl := nativeast.SymbolDeclarationsOf(sym)[0]
       // A `class` (declaration or expression — including a generic instantiation,
       // whose symbol still resolves to the class declaration) has a runtime value
       // binding; an interface / type alias / anonymous object literal does not, so
@@ -53,7 +53,7 @@ func Emplace_metadata_object(props IMetadataIteratorProps) *schemametadata.Metad
       // name. classRefOf gates on this.
       obj.IsClass = decl.Kind == nativeast.KindClassDeclaration || decl.Kind == nativeast.KindClassExpression
       if src := nativeast.GetSourceFileOfNode(decl); src != nil {
-        file := src.FileName()
+        file := string(src.FileName())
         obj.Source = &file
         // The Default modifier covers `export default class C {}`; a SEPARATE
         // `class C {}; export default C;` puts no modifier on the class, so also
@@ -126,7 +126,7 @@ func Emplace_metadata_object(props IMetadataIteratorProps) *schemametadata.Metad
   pred := func(symbol *nativeast.Symbol, node *nativeast.Node) bool {
     name := "<anonymous>"
     if symbol != nil {
-      name = symbol.Name
+      name = nativeast.SymbolNameOf(symbol)
     }
     // Diagnose ES #private before the symbol-key filter so JEV reports the
     // nominal member rather than its compiler-generated mangled name.
@@ -146,7 +146,7 @@ func Emplace_metadata_object(props IMetadataIteratorProps) *schemametadata.Metad
     // would declare an uninhabitable required property (#2226). Checked on the
     // SYMBOL rather than a declaration node so a late-bound member with no
     // reachable declaration is excluded too.
-    if symbol != nil && iterate_metadata_intersection_is_symbol_name(symbol.Name) {
+    if symbol != nil && iterate_metadata_intersection_is_symbol_name(nativeast.SymbolNameOf(symbol)) {
       rejectMember(name, "LLM evaluation does not support symbol-keyed properties.")
       return false
     }
@@ -180,24 +180,24 @@ func Emplace_metadata_object(props IMetadataIteratorProps) *schemametadata.Metad
       continue
     }
     var node *nativeast.Node
-    if len(symbol.Declarations) != 0 {
-      node = symbol.Declarations[0]
+    if len(nativeast.SymbolDeclarationsOf(symbol)) != 0 {
+      node = nativeast.SymbolDeclarationsOf(symbol)[0]
     }
     var typ *nativechecker.Type
     if node != nil {
       typ = props.Checker.GetTypeOfSymbolAtLocation(symbol, node)
     } else {
-      typ = nativechecker.Checker_getTypeOfPropertyOfType(props.Checker, props.Type, symbol.Name)
+      typ = nativechecker.Checker_getTypeOfPropertyOfType(props.Checker, props.Type, nativeast.SymbolNameOf(symbol))
     }
     if pred(symbol, node) == false || typ == nil {
       continue
     }
 
-    key := MetadataHelper.Literal_to_metadata(symbol.Name)
+    key := MetadataHelper.Literal_to_metadata(nativeast.SymbolNameOf(symbol))
     explore := MetadataFactory_IExplore{
       Top:       false,
       Object:    obj,
-      Property:  symbol.Name,
+      Property:  nativeast.SymbolNameOf(symbol),
       Parameter: nil,
       Nested:    nil,
       Aliased:   false,
@@ -213,7 +213,7 @@ func Emplace_metadata_object(props IMetadataIteratorProps) *schemametadata.Metad
       Explore:     explore,
       Intersected: false,
     })
-    value.Optional = symbol.Flags&nativeast.SymbolFlagsOptional != 0
+    value.Optional = nativeast.SymbolFlagsOf(symbol)&nativeast.SymbolFlagsOptional != 0
     insert(emplace_metadata_object_insert{
       Key:    key,
       Value:  value,
@@ -299,7 +299,7 @@ func emplace_metadata_object_touch_heritage(
     return
   }
   visited[symbol] = true
-  for _, decl := range symbol.Declarations {
+  for _, decl := range nativeast.SymbolDeclarationsOf(symbol) {
     if decl == nil {
       continue
     }
@@ -336,15 +336,24 @@ func emplace_metadata_object_touch_heritage(
         // The node walk reports the heritage expression's symbol and every
         // reference written in its type arguments (e.g. `extends Base<Id>`).
         schemametadata.MetadataDependency_touchTypeNode(checker, element)
-        expr := element.AsExpressionWithTypeArguments()
-        if expr == nil || expr.Expression == nil {
+        // Type heritage (interface extends and class implements) is a type
+        // reference on 7.1; class extends remains an expression. Older targets
+        // represent both forms as expressions with type arguments.
+        var name *nativeast.Node
+        switch element.Kind {
+        case nativeast.KindTypeReference:
+          name = element.AsTypeReferenceNode().TypeName
+        case nativeast.KindExpressionWithTypeArguments:
+          name = element.AsExpressionWithTypeArguments().Expression
+        }
+        if name == nil {
           continue
         }
-        target := checker.GetSymbolAtLocation(expr.Expression)
+        target := checker.GetSymbolAtLocation(name)
         if target == nil {
           continue
         }
-        if target.Flags&nativeast.SymbolFlagsAlias != 0 {
+        if nativeast.SymbolFlagsOf(target)&nativeast.SymbolFlagsAlias != 0 {
           if resolved := nativechecker.Checker_getAliasedSymbol(checker, target); resolved != nil {
             target = resolved
           }
@@ -366,10 +375,10 @@ func emplace_metadata_object_private_fields(checker *nativechecker.Checker, typ
   }
   visited[typ] = true
   sym := typ.Symbol()
-  if sym == nil || len(sym.Declarations) == 0 {
+  if sym == nil || len(nativeast.SymbolDeclarationsOf(sym)) == 0 {
     return false
   }
-  decl := sym.Declarations[0]
+  decl := nativeast.SymbolDeclarationsOf(sym)[0]
   var members []*nativeast.Node
   if decl.Kind == nativeast.KindClassDeclaration {
     if cd := decl.AsClassDeclaration(); cd != nil && cd.Members != nil {
@@ -441,7 +450,7 @@ func emplace_metadata_object_is_default_export(
     if target == nil {
       continue
     }
-    if target == sym || (len(target.Declarations) != 0 && target.Declarations[0] == decl) {
+    if target == sym || (len(nativeast.SymbolDeclarationsOf(target)) != 0 && nativeast.SymbolDeclarationsOf(target)[0] == decl) {
       return true
     }
   }
@@ -592,21 +601,21 @@ func emplace_metadata_object_intersection_append(
       continue
     }
     var node *nativeast.Node
-    if len(symbol.Declarations) != 0 {
-      node = symbol.Declarations[0]
+    if len(nativeast.SymbolDeclarationsOf(symbol)) != 0 {
+      node = nativeast.SymbolDeclarationsOf(symbol)[0]
     }
     var typ *nativechecker.Type
     if node != nil {
       typ = props.Checker.GetTypeOfSymbolAtLocation(symbol, node)
     } else {
-      typ = nativechecker.Checker_getTypeOfPropertyOfType(props.Checker, child, symbol.Name)
+      typ = nativechecker.Checker_getTypeOfPropertyOfType(props.Checker, child, nativeast.SymbolNameOf(symbol))
     }
     if pred(symbol, node) == false || typ == nil {
       continue
     }
 
     explore := props.Explore
-    explore.Property = symbol.Name
+    explore.Property = nativeast.SymbolNameOf(symbol)
     explore.Parameter = nil
     explore.Nested = nil
     explore.Aliased = false
@@ -622,9 +631,9 @@ func emplace_metadata_object_intersection_append(
       Intersected: false,
       Prunable:    props.Prunable,
     })
-    value.Optional = symbol.Flags&nativeast.SymbolFlagsOptional != 0
+    value.Optional = nativeast.SymbolFlagsOf(symbol)&nativeast.SymbolFlagsOptional != 0
     insert(emplace_metadata_object_insert{
-      Key:    MetadataHelper.Literal_to_metadata(symbol.Name),
+      Key:    MetadataHelper.Literal_to_metadata(nativeast.SymbolNameOf(symbol)),
       Value:  value,
       Symbol: symbol,
       Node:   node,
@@ -662,10 +671,10 @@ func emplace_metadata_object_intersection_has_duplicate_key(
       return true
     }
     for _, symbol := range collection.ApparentProperties(checker, child) {
-      if keys[symbol.Name] {
+      if keys[nativeast.SymbolNameOf(symbol)] {
         return true
       }
-      keys[symbol.Name] = true
+      keys[nativeast.SymbolNameOf(symbol)] = true
     }
   }
   return false

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

@@ -19,10 +19,10 @@ func Iterate_metadata_alias(props IMetadataIteratorProps) bool {
     return false
   }
   aliasSymbol := nativechecker_type_name_symbol(props.Type)
-  if aliasSymbol == nil || len(aliasSymbol.Declarations) == 0 {
+  if aliasSymbol == nil || len(nativeast.SymbolDeclarationsOf(aliasSymbol)) == 0 {
     return false
   }
-  if aliasSymbol.Declarations[0].Kind != nativeast.KindTypeAliasDeclaration {
+  if nativeast.SymbolDeclarationsOf(aliasSymbol)[0].Kind != nativeast.KindTypeAliasDeclaration {
     return false
   }
 

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

@@ -168,18 +168,18 @@ func iterate_metadata_constant_shared(checker *nativechecker.Checker, typ *nativ
     return false
   }
   symbol := typ.Symbol()
-  if symbol == nil || len(symbol.Declarations) == 0 {
+  if symbol == nil || len(nativeast.SymbolDeclarationsOf(symbol)) == 0 {
     return false
   }
-  declaration := symbol.Declarations[0]
+  declaration := nativeast.SymbolDeclarationsOf(symbol)[0]
   if declaration == nil || declaration.Kind != nativeast.KindEnumMember || declaration.Parent == nil {
     return false
   }
   // declaration merging (`enum E { a = 1 }` beside `enum E { b = 1 }`) spreads
   // one enum over several declarations
   declarations := []*nativeast.Node{declaration.Parent}
-  if symbol.Parent != nil && len(symbol.Parent.Declarations) != 0 {
-    declarations = symbol.Parent.Declarations
+  if nativeast.SymbolParentOf(symbol) != nil && len(nativeast.SymbolDeclarationsOf(nativeast.SymbolParentOf(symbol))) != 0 {
+    declarations = nativeast.SymbolDeclarationsOf(nativeast.SymbolParentOf(symbol))
   }
   // compare by value: a member's own type may be the fresh form of the
   // regular literal type the union holds

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

@@ -55,7 +55,7 @@ func Iterate_metadata_function(props IMetadataIteratorProps) bool {
     paramType := props.Checker.GetTypeOfSymbol(p)
     explore := props.Explore
     explore.Top = false
-    explore.Parameter = p.Name
+    explore.Parameter = nativeast.SymbolNameOf(p)
     metadata := Explore_metadata(Explore_metadata_IProps{
       Options:     props.Options,
       Checker:     props.Checker,
@@ -78,7 +78,7 @@ func Iterate_metadata_function(props IMetadataIteratorProps) bool {
       }
     }
     parameters = append(parameters, schemametadata.MetadataParameter_create(schemametadata.MetadataParameter{
-      Name:        p.Name,
+      Name:        nativeast.SymbolNameOf(p),
       Type:        metadata,
       TsType:      paramType,
       Description: metadata_node_description(p),

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

@@ -585,10 +585,10 @@ func iterate_metadata_intersection_is_removable_object_constraint(
     // nominal brand), so it is phantom and removable. typia's own tag is handled
     // as a constraint, not stripped here; any required string-keyed property might
     // be real data ??both keep the object as a constraint, not a removable brand.
-    if iterate_metadata_intersection_is_symbol_name(symbol.Name) {
+    if iterate_metadata_intersection_is_symbol_name(nativeast.SymbolNameOf(symbol)) {
       continue
     }
-    if symbol.Name == "typia.tag" || symbol.Flags&nativeast.SymbolFlagsOptional == 0 {
+    if nativeast.SymbolNameOf(symbol) == "typia.tag" || nativeast.SymbolFlagsOf(symbol)&nativeast.SymbolFlagsOptional == 0 {
       return false
     }
   }
@@ -654,7 +654,7 @@ func iterate_metadata_intersection_identify(
     }
   }
   for _, symbol := range collection.ApparentProperties(checker, typ) {
-    if symbol.Name == "typia.tag" {
+    if nativeast.SymbolNameOf(symbol) == "typia.tag" {
       return iterate_metadata_intersection_identity{Kind: "tag"}
     }
   }
@@ -784,7 +784,7 @@ func iterate_metadata_intersection_is_plain_object_only(
   }
 
   for _, symbol := range collection.ApparentProperties(checker, typ) {
-    if symbol.Name == "typia.tag" {
+    if nativeast.SymbolNameOf(symbol) == "typia.tag" {
       return false
     }
   }
@@ -927,7 +927,7 @@ func iterate_metadata_intersection_has_conflicting_required_literal(
       return false
     }
     for _, symbol := range collection.ApparentProperties(checker, child) {
-      if symbol.Flags&nativeast.SymbolFlagsOptional != 0 {
+      if nativeast.SymbolFlagsOf(symbol)&nativeast.SymbolFlagsOptional != 0 {
         continue
       }
       propertyType := iterate_metadata_intersection_property_type(checker, child, symbol)
@@ -935,14 +935,14 @@ func iterate_metadata_intersection_has_conflicting_required_literal(
       if ok == false {
         continue
       }
-      list := constraints[symbol.Name]
+      list := constraints[nativeast.SymbolNameOf(symbol)]
       for _, prev := range list {
         if iterate_metadata_intersection_literal_disjoint(prev, literal) {
           result = true
           return true
         }
       }
-      constraints[symbol.Name] = append(list, literal)
+      constraints[nativeast.SymbolNameOf(symbol)] = append(list, literal)
     }
     return false
   }
@@ -958,12 +958,12 @@ func iterate_metadata_intersection_property_type(
   if checker == nil || owner == nil || symbol == nil {
     return nil
   }
-  if len(symbol.Declarations) != 0 {
-    if typ := checker.GetTypeOfSymbolAtLocation(symbol, symbol.Declarations[0]); typ != nil {
+  if len(nativeast.SymbolDeclarationsOf(symbol)) != 0 {
+    if typ := checker.GetTypeOfSymbolAtLocation(symbol, nativeast.SymbolDeclarationsOf(symbol)[0]); typ != nil {
       return typ
     }
   }
-  return nativechecker.Checker_getTypeOfPropertyOfType(checker, owner, symbol.Name)
+  return nativechecker.Checker_getTypeOfPropertyOfType(checker, owner, nativeast.SymbolNameOf(symbol))
 }
 
 func iterate_metadata_intersection_literal_set(
@@ -1065,7 +1065,7 @@ func iterate_metadata_intersection_category(
     return "array"
   }
   for _, symbol := range collection.ApparentProperties(checker, typ) {
-    if symbol.Name == "typia.tag" {
+    if nativeast.SymbolNameOf(symbol) == "typia.tag" {
       return "tag"
     }
   }

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

@@ -4,12 +4,7 @@
 package metadata
 
 import (
-  "path/filepath"
   "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"
 )
 
 // TestJsDocLinkText verifies the metadata helper renders visible inline links.
@@ -29,11 +24,9 @@ import (
 // @evidence contracts/testing.md#behavioral-verification JSDoc is parsed from source and the link renderer returns descriptions and tags with qualified targets, labels, call suffixes, URLs and tag comments; a nil link renders empty.
 // @evidence contracts/testing.md#independent-expectations Authored JSDoc text defines the visible output; expected strings are literals.
 // @evidence contracts/testing.md#distinguishing-cases Qualified and labeled links, URL links and tag comments are separate rows with a nil control.
-// @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 parses an in-memory source with the typescript-go parser and calls the renderer, with no filesystem fixture or process.
+// @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 loads one authored TypeScript source through the in-process compiler binder and calls the renderer on its real property symbol. A test-owned fixture and Program are cleaned up without launching a compiler or native host process.
 func TestJsDocLinkText(t *testing.T) {
-  file := nativeparser.ParseSourceFile(
-    nativeast.SourceFileParseOptions{FileName: filepath.ToSlash(filepath.Join(t.TempDir(), "links.ts"))},
-    `interface ITarget {
+  program, file := jsDocTestSource(t, `interface ITarget {
   value: string;
 }
 interface IBox {
@@ -48,14 +41,11 @@ interface IBox {
    */
   field: string;
 }
-`,
-    nativecore.ScriptKindTS,
-  )
+`)
   member := file.Statements.Nodes[1].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")
   }
   description := metadata_node_description(symbol)
   if description == nil {

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

@@ -10,6 +10,7 @@ import (
   nativeast "github.com/microsoft/typescript-go/shim/ast"
   nativecore "github.com/microsoft/typescript-go/shim/core"
   nativeparser "github.com/microsoft/typescript-go/shim/parser"
+  nativetspath "github.com/microsoft/typescript-go/shim/tspath"
 )
 
 // TestJSDocParameterNameReadsQualifiedName verifies dotted JSDoc parameter names.
@@ -30,7 +31,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 Test function in process. The tagged test parses in-memory source with the typescript-go parser, with no filesystem fixture or process.
 func TestJSDocParameterNameReadsQualifiedName(t *testing.T) {
   file := nativeparser.ParseSourceFile(
-    nativeast.SourceFileParseOptions{FileName: filepath.ToSlash(filepath.Join(t.TempDir(), "qualified.ts"))},
+    nativeast.SourceFileParseOptions{FileName: nativetspath.RootedFilePath(filepath.ToSlash(filepath.Join(t.TempDir(), "qualified.ts")))},
     `interface Box {
   /**
    * @param input.value nested value

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

@@ -0,0 +1,44 @@
+//go:build typia_native_internal
+
+package metadata
+
+import (
+  "os"
+  "path/filepath"
+  "testing"
+
+  nativeast "github.com/microsoft/typescript-go/shim/ast"
+  "github.com/samchon/ttsc/packages/ttsc/driver"
+)
+
+// jsDocTestSource loads authored comments with the real compiler binder so
+// metadata tests consume compiler-owned symbols on either TypeScript target.
+// The caller selects declarations from the returned file; one Program can hold
+// every comment spelling in a table, and test cleanup closes that Program.
+func jsDocTestSource(t *testing.T, text string) (*driver.Program, *nativeast.SourceFile) {
+  t.Helper()
+  root := t.TempDir()
+  fileName := filepath.Join(root, "comments.ts")
+  for name, content := range map[string]string{
+    "comments.ts":   text,
+    "tsconfig.json": `{"compilerOptions":{"target":"es2022","module":"nodenext","moduleResolution":"nodenext","strict":true,"skipLibCheck":true,"types":[]},"files":["comments.ts"]}`,
+  } {
+    if err := os.WriteFile(filepath.Join(root, name), []byte(content), 0o644); err != nil {
+      t.Fatal(err)
+    }
+  }
+  program, diagnostics, err := driver.LoadProgram(root, "tsconfig.json", driver.LoadProgramOptions{})
+  if err != nil || driver.CountErrors(diagnostics) != 0 {
+    t.Fatalf("load JSDoc fixture: %v; %+v", err, diagnostics)
+  }
+  t.Cleanup(func() {
+    if err := program.Close(); err != nil {
+      t.Error(err)
+    }
+  })
+  source := program.SourceFile(fileName)
+  if source == nil {
+    t.Fatal("JSDoc source was not loaded")
+  }
+  return program, source
+}

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

@@ -4,13 +4,11 @@
 package metadata
 
 import (
-  "path/filepath"
+  "fmt"
   "reflect"
+  "strings"
   "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"
 )
 
@@ -25,16 +23,12 @@ import (
 //  3. Compare exact payloads, keeping literal stars, linked-text separation and
 //     Unicode prefixes that the JSDoc scanner treats as content.
 //
-// @evidence contracts/testing.md#behavioral-verification ParseSourceFile creates actual JSDoc nodes and metadata_node_js_doc_tags extracts their public metadata values; exact tag arrays expose added star payload or dropped legitimate description text.
+// @evidence contracts/testing.md#behavioral-verification One compiler Program binds all authored JSDoc-bearing declarations and metadata_node_js_doc_tags extracts their public metadata values; exact tag arrays expose added star payload or dropped legitimate description text.
 // @evidence contracts/testing.md#independent-expectations Literal arrays follow the JSDoc scanner's ASCII-started whitespace and CR/LF delimiter rules; Unicode-only prefixes and Unicode line characters remain content, as confirmed against TypeScript's independent JSDoc parser. Expected link labels, integer values and literal stars are authored separately from the metadata helper.
 // @evidence contracts/testing.md#distinguishing-cases Compact and braced tags, CRLF and ASCII horizontal whitespace, and ASCII-started mixed Unicode horizontal whitespace retain integer meaning; inline and continuation literal stars, Unicode-only prefix content and Unicode line characters prevent over-removal. Line and paragraph separators after an ASCII space must not be crossed to strip a genuine star. Linked descriptions retain their separating newline. All nineteen spellings report independent subtest identities.
-// @evidence contracts/testing.md#execution-ownership This tagged same-package Go unit directly calls the parser and owning private metadata helper in one test process, with an in-memory source and no native plugin host or filesystem fixture; the canonical typia_native_internal Go command executes its Test entry and subtests.
+// @evidence contracts/testing.md#execution-ownership This tagged same-package Go unit loads one test-owned source containing all nineteen distinct interfaces, selects their real compiler symbols and calls the private metadata helper. The canonical typia_native_internal command executes the Test and subtests; cleanup closes the shared in-process Program and removes its fixture, with no compiler or native host subprocess.
 func TestJsDocTypeTagBlankSeparation(t *testing.T) {
-  filename, err := filepath.Abs("type-tag.ts")
-  if err != nil {
-    t.Fatal(err)
-  }
-  for _, fixture := range []struct {
+  fixtures := []struct {
     name        string
     text        string
     description string
@@ -59,18 +53,18 @@ func TestJsDocTypeTagBlankSeparation(t *testing.T) {
     {"bom-content", "* @type int\n\ufeff*\n\ufeff* @minimum 3\n\ufeff*\n\ufeff* @title literal * marks", "*", "3\n\ufeff*\n\ufeff*"},
     {"zero-width-content", "* @type int\n\u200b*\n\u200b* @minimum 3\n\u200b*\n\u200b* @title literal * marks", "*", "3\n\u200b*\n\u200b*"},
     {"unicode-line-content", "* @type int\u2028 *\u2028 * @minimum 3\u2029 *\u2029 * @title literal * marks", "*", "3\u2029 *\u2029 *"},
-  } {
+  }
+  var source strings.Builder
+  for index, fixture := range fixtures {
+    fmt.Fprintf(&source, "interface Box%d {\n /**\n %s\n */\n field: number;\n}\n", index, fixture.text)
+  }
+  program, file := jsDocTestSource(t, source.String())
+  for index, fixture := range fixtures {
     t.Run(fixture.name, func(t *testing.T) {
-      file := nativeparser.ParseSourceFile(
-        nativeast.SourceFileParseOptions{FileName: filepath.ToSlash(filename)},
-        "interface Box {\n /**\n "+fixture.text+"\n */\n field: number;\n}\n",
-        nativecore.ScriptKindTS,
-      )
-      member := file.Statements.Nodes[0].AsInterfaceDeclaration().Members.Nodes[0]
-      symbol := &nativeast.Symbol{
-        Name:             "field",
-        ValueDeclaration: member,
-        Declarations:     []*nativeast.Node{member},
+      member := file.Statements.Nodes[index].AsInterfaceDeclaration().Members.Nodes[0]
+      symbol := program.Checker.GetSymbolAtLocation(member.Name())
+      if symbol == nil {
+        t.Fatal("comment property symbol was not bound")
       }
       wanted := []schemametadata.IJsDocTagInfo{
         {Name: "type", Text: []schemametadata.IJsDocTagInfo_IText{{Kind: "text", Text: "int"}}},

package/native/core/factories/numeric_range_factory_enforces_64bit_bounds_test.go

@@ -1,6 +1,7 @@
 package factories
 
 import (
+  nativecontext "github.com/samchon/typia/packages/typia/native/core/context"
   "testing"
 
   shimast "github.com/microsoft/typescript-go/shim/ast"
@@ -23,7 +24,7 @@ import (
 // @evidence contracts/testing.md#distinguishing-cases Number int32/uint32/int64/uint64, bigint int64/uint64 and unknown controls distinguish signedness, width, exact string construction and unrestricted fallback.
 // @evidence contracts/testing.md#execution-ownership The canonical native Go command (pnpm test:go:native) runs this same-package Test function in process. It builds AST nodes in memory with no checker, filesystem fixture or process.
 func TestNumericRangeFactoryEnforces64BitBounds(t *testing.T) {
-  input := numericRangeFactory_factory.NewIdentifier("input")
+  input := nativecontext.NodeFactoryOf().NewIdentifier("input")
 
   for _, name := range []string{"int64", "uint64"} {
     node := NumericRangeFactory.Bigint(name, input)