typia 13.1.0 → 13.1.19

package/native/core/factories/identifier_factory_postfix_escapes_every_key_test.go

@@ -0,0 +1,147 @@
+package factories
+
+import (
+  "encoding/json"
+  "strings"
+  "testing"
+)
+
+// TestIdentifierFactoryPostfixEscapesEveryKey verifies emitted accessor paths.
+//
+// Postfix returns JavaScript source that callers splice into the emit as
+// `_path + <postfix>`, so it carries two nested escaping levels: the key becomes
+// a JSON literal, and that literal sits inside the JavaScript literal returned.
+// Escaping one level and not the other emitted a file that does not parse for a
+// `"` key, and a path that JSON.parse rejects inside _createStandardSchema for a
+// control-character key. The expected strings below come from the contract that
+// typia's own runtime helper _accessExpressionAsString implements for dynamic
+// keys, `variable(str) ? ".{str}" : "[{JSON.stringify(str)}]"`, not from what
+// the emitter happens to produce.
+//
+//  1. Assert the exact source text Postfix returns for identifier keys, quoting
+//     keys, escape-sensitive keys, control characters, and non-ASCII keys.
+//  2. Decode every result as JSON twice and assert the original key survives.
+//  3. Assert the identifier fast path stays a dotted accessor, so ordinary keys
+//     and prototype-shadowing keys keep their existing output.
+func TestIdentifierFactoryPostfixEscapesEveryKey(t *testing.T) {
+  for _, item := range []struct {
+    name     string
+    key      string
+    expected string
+  }{
+    // Identifier fast path: no escaping is possible, so output is unchanged.
+    {"identifier", "field", `".field"`},
+    {"underscore", "_private", `"._private"`},
+    {"dollar", "$ref", `".$ref"`},
+    // A prototype-shadowing key is still a plain property access, because the
+    // emitted accessor reads the property and never the prototype.
+    {"proto", "__proto__", `".__proto__"`},
+    {"constructor", "constructor", `".constructor"`},
+    {"toString", "toString", `".toString"`},
+    // Ordinary quoted keys: byte-identical to the pre-fix output.
+    {"hyphen", "a-b", `"[\"a-b\"]"`},
+    {"space", "not valid", `"[\"not valid\"]"`},
+    {"empty", "", `"[\"\"]"`},
+    {"digit first", "0abc", `"[\"0abc\"]"`},
+    {"dotted", "a.b", `"[\"a.b\"]"`},
+    {"bracket", "a[0]", `"[\"a[0]\"]"`},
+    {"reserved", "for", `"[\"for\"]"`},
+    // Neither quote nor backslash, so no escape applies at either level.
+    {"single quote", "a'b", `"[\"a'b\"]"`},
+    {"backtick", "a`b", "\"[\\\"a`b\\\"]\""},
+    {"template hole", "a${b}c", `"[\"a${b}c\"]"`},
+    // The double quote is escaped once per level: `"` -> `\"` -> `\\\"`.
+    {"double quote", `a"b`, `"[\"a\\\"b\"]"`},
+    {"only double quote", `"`, `"[\"\\\"\"]"`},
+    // The backslash likewise. Escaping it once left the emitted path saying
+    // `["a\b"]`, which JSON.parse reads back as a backspace, not a backslash.
+    {"backslash", `a\b`, `"[\"a\\\\b\"]"`},
+    {"only backslash", `\`, `"[\"\\\\\"]"`},
+    {"quote and backslash", `a"\b`, `"[\"a\\\"\\\\b\"]"`},
+    // Control characters need a JSON escape; a raw one makes JSON.parse throw.
+    {"newline", "a\nb", `"[\"a\\nb\"]"`},
+    {"tab", "a\tb", `"[\"a\\tb\"]"`},
+    {"carriage return", "a\rb", `"[\"a\\rb\"]"`},
+    {"backspace", "a\bb", `"[\"a\\bb\"]"`},
+    {"form feed", "a\fb", `"[\"a\\fb\"]"`},
+    {"null", "a\x00b", `"[\"a\\u0000b\"]"`},
+    {"unit separator", "a\x1fb", `"[\"a\\u001fb\"]"`},
+    // strconv.Quote wrote `\a` and `\v` here. JavaScript has no `\a`, so it
+    // decoded to a plain "a" and silently changed the key.
+    {"bell", "a\x07b", `"[\"a\\u0007b\"]"`},
+    {"vertical tab", "a\x0bb", `"[\"a\\u000bb\"]"`},
+    // A line terminator to JavaScript but an ordinary character to JSON, so the
+    // escape belongs in the source and must not reach the path itself: the
+    // emitted `\u2028` decodes back to the raw character JSON.stringify writes.
+    {"line separator", "a\u2028b", `"[\"a\u2028b\"]"`},
+    {"paragraph separator", "a\u2029b", `"[\"a\u2029b\"]"`},
+    // Printable non-ASCII stays raw, exactly as JSON.stringify leaves it.
+    {"non ascii", "한글", `"[\"한글\"]"`},
+    {"emoji", "a\U0001F600b", "\"[\\\"a\U0001F600b\\\"]\""},
+    // strconv.Quote wrote `\U0001d173` for a non-printable astral rune, and
+    // JavaScript has no `\U` escape at all; it read back as "U0001d173".
+    {"astral format", "a\U0001D173b", "\"[\\\"a\U0001D173b\\\"]\""},
+    // A lone surrogate arrives WTF-8 encoded and has no valid UTF-8 form, so an
+    // escape is the only way to carry it.
+    {"lone surrogate", "a\xed\xa0\x80b", `"[\"a\\ud800b\"]"`},
+    // No escape denotes a byte that is not UTF-8 at all.
+    {"invalid utf8", "a\xffb", `"[\"a\\ufffdb\"]"`},
+  } {
+    t.Run(item.name, func(t *testing.T) {
+      output := IdentifierFactory.Postfix(item.key)
+      if output != item.expected {
+        t.Fatalf("Postfix(%q)\n got: %s\nwant: %s", item.key, output, item.expected)
+      }
+      identifierFactoryPostfixRoundTrip(t, item.key, output)
+    })
+  }
+}
+
+// identifierFactoryPostfixRoundTrip decodes the emitted source the way the
+// runtime does: JavaScript reads the outer literal, then _createStandardSchema
+// hands the bracketed key to JSON.parse. encoding/json stands in for both,
+// which makes this an independent check that the escaping is real rather than a
+// restatement of the emitter's own logic.
+func identifierFactoryPostfixRoundTrip(t *testing.T, key string, output string) {
+  t.Helper()
+  var path string
+  if err := json.Unmarshal([]byte(output), &path); err != nil {
+    t.Fatalf("Postfix(%q) is not a JavaScript string literal: %s (%v)", key, output, err)
+  }
+  if strings.HasPrefix(path, ".") {
+    if path[1:] != key {
+      t.Fatalf("Postfix(%q) dotted accessor lost the key: %q", key, path)
+    }
+    return
+  }
+  if !strings.HasPrefix(path, "[") || !strings.HasSuffix(path, "]") {
+    t.Fatalf("Postfix(%q) is neither a dotted nor a bracketed accessor: %q", key, path)
+  }
+  var decoded string
+  if err := json.Unmarshal([]byte(path[1:len(path)-1]), &decoded); err != nil {
+    t.Fatalf("Postfix(%q) bracketed key is not JSON: %q (%v)", key, path, err)
+  }
+  if want := identifierFactoryPostfixDecodable(key); decoded != want {
+    t.Fatalf("Postfix(%q) round-tripped to %q, want %q", key, decoded, want)
+  }
+}
+
+// identifierFactoryPostfixDecodable states what a JSON decoder can return for
+// `key`. encoding/json replaces an unpaired surrogate and never yields invalid
+// UTF-8, so those two inputs come back as the replacement character even though
+// the emitted escape itself is exact.
+func identifierFactoryPostfixDecodable(key string) string {
+  var builder strings.Builder
+  for i := 0; i < len(key); {
+    // Detect a WTF-8 surrogate here rather than calling the factory's own
+    // helper, so this expectation stays independent of the code under test.
+    if len(key)-i >= 3 && key[i] == 0xed && key[i+1] >= 0xa0 && key[i+1] <= 0xbf {
+      builder.WriteRune('�')
+      i += 3
+      continue
+    }
+    builder.WriteByte(key[i])
+    i++
+  }
+  return strings.ToValidUTF8(builder.String(), "�")
+}

package/native/core/factories/identifier_factory_postfix_survives_every_code_point_test.go

@@ -0,0 +1,86 @@
+package factories
+
+import (
+  "encoding/json"
+  "fmt"
+  "strings"
+  "testing"
+  "unicode/utf8"
+)
+
+// TestIdentifierFactoryPostfixSurvivesEveryCodePoint verifies total escaping.
+//
+// The emitted accessor is spliced into the emit as source text, and nothing
+// downstream parses the file, so a key the escaper mishandles ships as a broken
+// artifact behind a successful build. The table-driven case list pins the
+// characters that actually regressed; this one closes the class by sweeping the
+// whole input space, because the escape decision is per rune and a sampled
+// matrix cannot prove a per-rune rule. encoding/json decodes the result, which
+// is an implementation typia does not own and therefore a real oracle: JSON
+// string syntax is a subset of JavaScript string syntax, so a literal it accepts
+// also parses in the emitted file.
+//
+//  1. Sweep every scalar value and assert the key round-trips exactly.
+//  2. Sweep every surrogate code unit and assert the WTF-8 form survives as an
+//     escape rather than corrupting the literal.
+//  3. Sweep every single byte, including the ones that are not UTF-8, and assert
+//     the emitted literal still decodes.
+func TestIdentifierFactoryPostfixSurvivesEveryCodePoint(t *testing.T) {
+  for code := rune(0); code <= utf8.MaxRune; code++ {
+    if code >= 0xd800 && code <= 0xdfff {
+      continue // Not a scalar value; covered by the surrogate sweep below.
+    }
+    key := "a" + string(code) + "b"
+    if decoded := identifierFactoryPostfixDecode(t, key); decoded != key {
+      t.Fatalf("U+%04X: Postfix round-tripped to %q, want %q", code, decoded, key)
+    }
+  }
+
+  for unit := rune(0xd800); unit <= 0xdfff; unit++ {
+    key := "a" + string([]byte{
+      0xe0 | byte(unit>>12),
+      0x80 | byte((unit>>6)&0x3f),
+      0x80 | byte(unit&0x3f),
+    }) + "b"
+    output := IdentifierFactory.Postfix(key)
+    // The inner level writes `\ud800` and the outer level escapes that
+    // backslash, so the emitted source carries `\\ud800`.
+    if want := fmt.Sprintf(`\\u%04x`, unit); !strings.Contains(output, want) {
+      t.Fatalf("U+%04X: lone surrogate was not escaped as %s: %s", unit, want, output)
+    }
+    // The decoder replaces an unpaired surrogate, so assert the literal stays
+    // well formed rather than demanding the original bytes back.
+    identifierFactoryPostfixDecode(t, key)
+  }
+
+  for value := 0; value <= 0xff; value++ {
+    key := "a" + string([]byte{byte(value)}) + "b"
+    decoded := identifierFactoryPostfixDecode(t, key)
+    if utf8.ValidString(key) && decoded != key {
+      t.Fatalf("byte 0x%02X: Postfix round-tripped to %q, want %q", value, decoded, key)
+    }
+  }
+}
+
+// identifierFactoryPostfixDecode reads the emitted source the way the runtime
+// does and fails the test if any layer rejects it: JavaScript parses the outer
+// literal, then _createStandardSchema hands the bracketed key to JSON.parse.
+func identifierFactoryPostfixDecode(t *testing.T, key string) string {
+  t.Helper()
+  output := IdentifierFactory.Postfix(key)
+  var path string
+  if err := json.Unmarshal([]byte(output), &path); err != nil {
+    t.Fatalf("Postfix(%q) is not a string literal: %s (%v)", key, output, err)
+  }
+  if strings.HasPrefix(path, ".") {
+    return path[1:]
+  }
+  if !strings.HasPrefix(path, "[") || !strings.HasSuffix(path, "]") {
+    t.Fatalf("Postfix(%q) is not an accessor: %q", key, path)
+  }
+  var decoded string
+  if err := json.Unmarshal([]byte(path[1:len(path)-1]), &decoded); err != nil {
+    t.Fatalf("Postfix(%q) bracketed key is not JSON: %q (%v)", key, path, err)
+  }
+  return decoded
+}

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

@@ -129,15 +129,13 @@ func metadata_explore_symbol_name(node *nativeast.Node, name string) string {
   return name
 }
 
-func metadata_get_type_arguments(checker *nativechecker.Checker, typ *nativechecker.Type) (output []*nativechecker.Type) {
+func metadata_get_type_arguments(checker *nativechecker.Checker, typ *nativechecker.Type) []*nativechecker.Type {
   if checker == nil || typ == nil {
     return nil
   }
-  defer func() {
-    if recover() != nil {
-      output = nil
-    }
-  }()
+  if typ.Flags()&nativechecker.TypeFlagsObject == 0 || typ.ObjectFlags()&nativechecker.ObjectFlagsReference == 0 {
+    return nil
+  }
   return checker.GetTypeArguments(typ)
 }
 
@@ -153,6 +151,21 @@ func metadata_get_function_node(typ *nativechecker.Type) *nativeast.Node {
   if nativeast.IsFunctionLike(node) {
     return node
   }
+  // The global `Function` interface (declared in a default `lib.*.d.ts`) is
+  // callable and newable at runtime, so a `Function`-typed member is a function,
+  // not a structural object: `constructor: Function` on the global `Object`
+  // interface, an explicit `x: Function`, or any member inherited through
+  // `extends Object`. Its symbol resolves to an `InterfaceDeclaration` rather
+  // than a function-like node, so without this branch it is expanded
+  // structurally (`{ prototype, length, arguments, caller, name }`) and its
+  // `typeof` is checked as `"object"` even though a real function reports
+  // `"function"`, making `is<Object>` universally false (#2178). Returning the
+  // interface declaration routes the member through the same function path typia
+  // already uses for `() => void` members: a lenient pass under default options
+  // and a signature-based check under `functional`.
+  if metadata_is_global_function_interface(symbol, node) {
+    return node
+  }
   if nativeast.IsPropertyAssignment(node) {
     initializer := node.AsPropertyAssignment().Initializer
     if nativeast.IsFunctionLike(initializer) {
@@ -268,6 +281,25 @@ func metadata_node_type_js_doc_tags(symbol *nativeast.Symbol) []schemametadata.I
   return metadata_node_js_doc_tags(symbol)
 }
 
+// metadata_is_global_function_interface reports whether the type behind `symbol`
+// is the global `Function` interface from a TypeScript default library. The
+// match is intentionally narrow — the symbol name is exactly `"Function"`, its
+// first declaration is an `InterfaceDeclaration`, and that declaration lives in a
+// `lib.*.d.ts` — so it recognizes only the lib `Function` and never a
+// user-declared `interface Function`, a `function Function()` value, or any
+// other callable object type (a hybrid `interface Foo { (): void; x: number }`
+// keeps its data properties). 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" {
+    return false
+  }
+  if node == nil || node.Kind != nativeast.KindInterfaceDeclaration {
+    return false
+  }
+  return metadata_symbol_from_default_lib(symbol)
+}
+
 // metadata_symbol_from_default_lib reports whether the symbol's first locatable
 // declaration lives in a TypeScript default library file. Default library files
 // are always named `lib.<target>.d.ts` regardless of the install directory, so
@@ -283,6 +315,28 @@ func metadata_symbol_from_default_lib(symbol *nativeast.Symbol) bool {
   return false
 }
 
+// metadata_symbol_from_declaration_file reports whether the symbol's first
+// locatable declaration lives in a `.d.ts` declaration file. It widens
+// metadata_symbol_from_default_lib beyond the TypeScript default libraries
+// (lib.*.d.ts) to any ambient declaration file, because a built-in native can be
+// declared by an ambient package rather than a default lib — the `File` and
+// `Blob` globals Node adds through @types/node are declared in `.d.ts` files that
+// are not `lib.*.d.ts`. Native classification uses this to keep a real built-in
+// native (declared in a `.d.ts`, whichever library) native, while a user type
+// that merely shares a native's name — an `interface File { name; size }` in a
+// `.ts` module — is not a declaration and falls through to the structural object
+// path (#2200).
+func metadata_symbol_from_declaration_file(symbol *nativeast.Symbol) bool {
+  for _, node := range metadata_node_declarations(symbol) {
+    src := nativeast.GetSourceFileOfNode(node)
+    if src == nil {
+      continue
+    }
+    return src.IsDeclarationFile
+  }
+  return false
+}
+
 func metadata_is_default_lib_file_name(fileName string) bool {
   slash := strings.ReplaceAll(fileName, "\\", "/")
   base := slash
@@ -407,13 +461,86 @@ func metadata_js_doc_comment_text(list *nativeast.NodeList) string {
   }
   parts := []string{}
   for _, node := range list.Nodes {
-    if node != nil {
+    if node == nil {
+      continue
+    }
+    switch node.Kind {
+    case nativeast.KindJSDocText:
       parts = append(parts, node.Text())
+    case nativeast.KindJSDocLink,
+      nativeast.KindJSDocLinkCode,
+      nativeast.KindJSDocLinkPlain:
+      parts = append(parts, metadata_js_doc_link_text(node))
     }
   }
   return metadata_clean_js_doc_text(strings.Join(parts, ""))
 }
 
+func metadata_js_doc_link_text(node *nativeast.Node) string {
+  if node == nil {
+    return ""
+  }
+  name := node.Name()
+  text := strings.Trim(node.Text(), " ")
+  if name == nil {
+    return text
+  }
+  nameText := metadata_js_doc_entity_name_text(name)
+  if (nameText == "http" || nameText == "https") && strings.HasPrefix(text, "://") {
+    target := nameText + text
+    index := strings.IndexAny(target, " |")
+    if index == -1 {
+      return target
+    }
+    label := metadata_js_doc_link_label(target[index:])
+    if label != "" {
+      return label
+    }
+    return target[:index]
+  }
+
+  suffix := ""
+  if strings.HasPrefix(text, "()") {
+    suffix = "()"
+    text = text[2:]
+  }
+  if label := metadata_js_doc_link_label(text); label != "" {
+    return label
+  }
+  return nameText + suffix
+}
+
+func metadata_js_doc_link_label(text string) string {
+  text = strings.TrimLeft(text, " ")
+  text = strings.TrimPrefix(text, "|")
+  return strings.TrimSpace(text)
+}
+
+func metadata_js_doc_entity_name_text(node *nativeast.Node) string {
+  if node == nil {
+    return ""
+  }
+  switch node.Kind {
+  case nativeast.KindIdentifier:
+    return node.Text()
+  case nativeast.KindQualifiedName:
+    name := node.AsQualifiedName()
+    if name == nil {
+      return ""
+    }
+    return metadata_js_doc_entity_name_text(name.Left) + "." + metadata_js_doc_entity_name_text(name.Right)
+  case nativeast.KindPropertyAccessExpression:
+    return metadata_js_doc_entity_name_text(node.Expression()) + "." + metadata_js_doc_entity_name_text(node.Name())
+  case nativeast.KindParenthesizedExpression,
+    nativeast.KindExpressionWithTypeArguments:
+    return metadata_js_doc_entity_name_text(node.Expression())
+  case nativeast.KindJSDocNameReference:
+    return metadata_js_doc_entity_name_text(node.Name())
+  default:
+    return ""
+  }
+}
+
 func metadata_clean_js_doc_text(text string) string {
   text = strings.ReplaceAll(text, "\r\n", "\n")
   text = strings.ReplaceAll(text, "\r", "\n")

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

@@ -67,24 +67,61 @@ func Emplace_metadata_object(props IMetadataIteratorProps) *schemametadata.Metad
       // plain.classify cannot soundly field-copy (Object.create + assign) a class
       // that has them — and the PROTOTYPE CHAIN matters: a field-copied subclass
       // of a #private-bearing base would equally throw "Cannot read private
-      // member". The type system hides #private from ApparentProperties, so detect
-      // it on the class declaration(s), walking the `extends` chain. Additive flag,
-      // read only by the classify programmer.
+      // member". A `#private` member DOES surface in ApparentProperties (as a
+      // mangled key), so the member filter below must drop it from the validated
+      // shape; here it is detected on the class declaration(s) — where its
+      // KindPrivateIdentifier name is unambiguous and statics are skippable —
+      // walking the `extends` chain. Additive flag, read only by the classify
+      // programmer.
       if emplace_metadata_object_private_fields(props.Checker, props.Type, map[*nativechecker.Type]bool{}) {
         obj.PrivateFields = true
       }
     }
   }
 
+  // Report the `extends` / `implements` chain to the dependency listener. The
+  // apparent-property walk below already registers the declaring file of every
+  // inherited member, but a base that currently contributes no property (an
+  // empty interface or class) would otherwise stay invisible — and gaining its
+  // first property is exactly the change that must invalidate the consumer.
+  if props.Type != nil && schemametadata.MetadataDependency_active(props.Checker) {
+    emplace_metadata_object_touch_heritage(props.Checker, props.Type.Symbol(), map[*nativeast.Symbol]bool{})
+  }
+
   isClass := props.Type != nil && props.Type.IsClass()
   isProperty := emplace_metadata_object_significant(props.Options.Functional, props.Options.Methods)
-  pred := func(node *nativeast.Node) bool {
+  pred := func(symbol *nativeast.Symbol, node *nativeast.Node) bool {
+    // A `symbol`-keyed member (`[uniqueSymbol]: T`, `[Symbol.toStringTag]: T`,
+    // ...) is not a string / number key: it is unreachable through the string
+    // index access typia emits, `JSON.stringify` ignores it, and JSON Schema has
+    // no representation for it. So it is not part of the structural,
+    // externally-observable shape — exclude it exactly as a `private`/`protected`
+    // keyword member and an ES `#private` one. The checker escapes such a member
+    // name with the 0xFE `InternalSymbolNamePrefix`, and ApparentProperties
+    // otherwise surfaces it under that mangled name, which no runtime object
+    // carries: every real value would fail its own guard, and the emitted schema
+    // 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) {
+      return false
+    }
     if node == nil {
       return true
     }
     if isClass && node.ModifierFlags()&(nativeast.ModifierFlagsPrivate|nativeast.ModifierFlagsProtected) != 0 {
       return false
     }
+    // An ES `#private` member (field, method, or accessor) carries no
+    // Private/Protected modifier — its identity is a KindPrivateIdentifier name.
+    // It is installed only by the constructor and is unreachable via index
+    // access, so it is not part of the structural shape; exclude it exactly as a
+    // `private`/`protected` keyword member (see ClassNonPublic). ApparentProperties
+    // otherwise surfaces it as a mangled key that no runtime object carries, so
+    // every real instance would fail its own guard (#2213).
+    if isClass && node.Name() != nil && node.Name().Kind == nativeast.KindPrivateIdentifier {
+      return false
+    }
     return isProperty(node)
   }
 
@@ -111,7 +148,7 @@ func Emplace_metadata_object(props IMetadataIteratorProps) *schemametadata.Metad
     } else {
       typ = nativechecker.Checker_getTypeOfPropertyOfType(props.Checker, props.Type, symbol.Name)
     }
-    if (node != nil && pred(node) == false) || typ == nil {
+    if pred(symbol, node) == false || typ == nil {
       continue
     }
 
@@ -197,6 +234,77 @@ func Emplace_metadata_object(props IMetadataIteratorProps) *schemametadata.Metad
   return obj
 }
 
+// emplace_metadata_object_touch_heritage reports every `extends` / `implements`
+// heritage target of `symbol`'s class / interface declarations to the
+// dependency listener, following the chain recursively so intermediate empty
+// bases register too. Import aliases resolve to their final target symbol,
+// whose declarations carry the real declaring files. Walking runs only while a
+// listener is active (see the call site), so ordinary analysis pays nothing.
+func emplace_metadata_object_touch_heritage(
+  checker *nativechecker.Checker,
+  symbol *nativeast.Symbol,
+  visited map[*nativeast.Symbol]bool,
+) {
+  if checker == nil || symbol == nil || visited[symbol] {
+    return
+  }
+  visited[symbol] = true
+  for _, decl := range symbol.Declarations {
+    if decl == nil {
+      continue
+    }
+    var clauses *nativeast.NodeList
+    switch decl.Kind {
+    case nativeast.KindClassDeclaration:
+      if cd := decl.AsClassDeclaration(); cd != nil {
+        clauses = cd.HeritageClauses
+      }
+    case nativeast.KindClassExpression:
+      if ce := decl.AsClassExpression(); ce != nil {
+        clauses = ce.HeritageClauses
+      }
+    case nativeast.KindInterfaceDeclaration:
+      if id := decl.AsInterfaceDeclaration(); id != nil {
+        clauses = id.HeritageClauses
+      }
+    }
+    if clauses == nil {
+      continue
+    }
+    for _, clause := range clauses.Nodes {
+      if clause == nil || clause.Kind != nativeast.KindHeritageClause {
+        continue
+      }
+      hc := clause.AsHeritageClause()
+      if hc == nil || hc.Types == nil {
+        continue
+      }
+      for _, element := range hc.Types.Nodes {
+        if element == nil {
+          continue
+        }
+        // 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 {
+          continue
+        }
+        target := checker.GetSymbolAtLocation(expr.Expression)
+        if target == nil {
+          continue
+        }
+        if target.Flags&nativeast.SymbolFlagsAlias != 0 {
+          if resolved := nativechecker.Checker_getAliasedSymbol(checker, target); resolved != nil {
+            target = resolved
+          }
+        }
+        emplace_metadata_object_touch_heritage(checker, target, visited)
+      }
+    }
+  }
+}
+
 // emplace_metadata_object_private_fields reports whether `typ` or any class in
 // its `extends` chain declares an INSTANCE ES #private member — which field-copy
 // (Object.create + assign) cannot reconstruct, so plain.classify must reject it.
@@ -350,7 +458,7 @@ func emplace_metadata_object_intersection(
   props IMetadataIteratorProps,
   obj *schemametadata.MetadataObjectType,
   insert func(emplace_metadata_object_insert) *schemametadata.MetadataProperty,
-  pred func(node *nativeast.Node) bool,
+  pred func(symbol *nativeast.Symbol, node *nativeast.Node) bool,
 ) bool {
   if props.Checker == nil ||
     props.Type == nil ||
@@ -424,7 +532,7 @@ func emplace_metadata_object_intersection_append(
   props IMetadataIteratorProps,
   child *nativechecker.Type,
   insert func(emplace_metadata_object_insert) *schemametadata.MetadataProperty,
-  pred func(node *nativeast.Node) bool,
+  pred func(symbol *nativeast.Symbol, node *nativeast.Node) bool,
 ) bool {
   if props.Checker == nil || child == nil || len(props.Components.IndexInfos(props.Checker, child)) != 0 {
     return false
@@ -443,7 +551,7 @@ func emplace_metadata_object_intersection_append(
     } else {
       typ = nativechecker.Checker_getTypeOfPropertyOfType(props.Checker, child, symbol.Name)
     }
-    if (node != nil && pred(node) == false) || typ == nil {
+    if pred(symbol, node) == false || typ == nil {
       continue
     }
 

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

@@ -9,6 +9,12 @@ func Iterate_metadata(props IMetadataIteratorProps) {
   if props.Type == nil {
     return
   }
+  // Every type the analysis reads funnels through here (top types, union and
+  // intersection members, alias targets, array / tuple elements, generic
+  // arguments, property types), so this single touch reports the declaration
+  // files of the whole consulted type graph to the dependency listener the
+  // project transform host registers (see schemas/metadata/MetadataDependency).
+  schemametadata.MetadataDependency_touchType(props.Checker, props.Type)
   if props.Type.IsTypeParameter() == true {
     if props.Errors != nil {
       *props.Errors = append(*props.Errors, MetadataFactory_IError{

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

@@ -3,6 +3,7 @@ package metadata
 import (
   nativechecker "github.com/microsoft/typescript-go/shim/checker"
   schemametadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+  nativeutils "github.com/samchon/typia/packages/typia/native/core/utils"
 )
 
 func Iterate_metadata_function(props IMetadataIteratorProps) bool {
@@ -36,16 +37,8 @@ func Iterate_metadata_function(props IMetadataIteratorProps) bool {
 
   signature := signatures[0]
   returnType := props.Checker.GetReturnTypeOfSignature(signature)
-  async := false
-  if returnType != nil {
-    if symbol := returnType.Symbol(); symbol != nil && symbol.Name == "Promise" {
-      generic := metadata_get_type_arguments(props.Checker, returnType)
-      if len(generic) != 0 {
-        returnType = generic[0]
-      }
-      async = true
-    }
-  }
+  promised := nativeutils.PromiseTypeFactory.Resolve(props.Checker, returnType)
+  returnType = promised.Type
 
   parameters := make([]*schemametadata.MetadataParameter, 0, len(signature.Parameters()))
   for _, p := range signature.Parameters() {
@@ -87,7 +80,7 @@ func Iterate_metadata_function(props IMetadataIteratorProps) bool {
   props.Metadata.Functions = append(props.Metadata.Functions, schemametadata.MetadataFunction_create(schemametadata.MetadataFunction{
     Parameters: parameters,
     Output:     output,
-    Async:      async,
+    Async:      promised.Async,
   }))
   return true
 }