typia 13.1.1 → 13.1.19

package/native/core/schemas/metadata/MetadataCollection.go

@@ -1,9 +1,12 @@
 package metadata
 
 import (
+  "hash/fnv"
   "maps"
   "slices"
+  "strconv"
   "strings"
+  "unicode"
 
   nativeast "github.com/microsoft/typescript-go/shim/ast"
   nativechecker "github.com/microsoft/typescript-go/shim/checker"
@@ -28,7 +31,9 @@ type MetadataCollection struct {
   arrays_order_        []*nativechecker.Type
   tuples_order_        []*nativechecker.Type
 
-  names_                 map[string]map[*nativechecker.Type]string
+  names_                 map[*nativechecker.Type]string
+  allocated_names_       map[string]bool
+  name_counters_         map[string]int
   type_full_names_       map[*nativechecker.Type]string
   full_names_            map[*nativechecker.Type]string
   display_names_         map[*nativechecker.Type]string
@@ -96,7 +101,9 @@ func NewMetadataCollection(options ...*MetadataCollection_IOptions) *MetadataCol
     arrays_order_:        []*nativechecker.Type{},
     tuples_order_:        []*nativechecker.Type{},
 
-    names_:                 map[string]map[*nativechecker.Type]string{},
+    names_:                 map[*nativechecker.Type]string{},
+    allocated_names_:       map[string]bool{},
+    name_counters_:         map[string]int{},
     object_index_:          0,
     recursive_array_index_: 0,
     recursive_tuple_index_: 0,
@@ -126,7 +133,9 @@ func (collection *MetadataCollection) Clone() *MetadataCollection {
     arrays_order_:        slices.Clone(collection.arrays_order_),
     tuples_order_:        slices.Clone(collection.tuples_order_),
 
-    names_:                 make(map[string]map[*nativechecker.Type]string, len(collection.names_)),
+    names_:                 maps.Clone(collection.names_),
+    allocated_names_:       maps.Clone(collection.allocated_names_),
+    name_counters_:         maps.Clone(collection.name_counters_),
     type_full_names_:       maps.Clone(collection.type_full_names_),
     full_names_:            maps.Clone(collection.full_names_),
     display_names_:         maps.Clone(collection.display_names_),
@@ -142,9 +151,6 @@ func (collection *MetadataCollection) Clone() *MetadataCollection {
   for k, v := range collection.object_unions_ {
     output.object_unions_[k] = slices.Clone(v)
   }
-  for k, v := range collection.names_ {
-    output.names_[k] = maps.Clone(v)
-  }
   return output
 }
 
@@ -171,7 +177,7 @@ func (collection *MetadataCollection) StoreExploreCache(key MetadataCollection_E
 
 func (collection *MetadataCollection) ApparentProperties(checker *nativechecker.Checker, typ *nativechecker.Type) []*nativeast.Symbol {
   if collection == nil {
-    return nativechecker.Checker_getApparentProperties(checker, typ)
+    return metadataCollection_touchProperties(checker, nativechecker.Checker_getApparentProperties(checker, typ))
   }
   if collection.apparent_properties_ == nil {
     collection.apparent_properties_ = map[*nativechecker.Type][]*nativeast.Symbol{}
@@ -179,11 +185,22 @@ func (collection *MetadataCollection) ApparentProperties(checker *nativechecker.
   if value, ok := collection.apparent_properties_[typ]; ok {
     return value
   }
-  value := nativechecker.Checker_getApparentProperties(checker, typ)
+  value := metadataCollection_touchProperties(checker, nativechecker.Checker_getApparentProperties(checker, typ))
   collection.apparent_properties_[typ] = value
   return value
 }
 
+// metadataCollection_touchProperties reports each enumerated property symbol to
+// the dependency listener. Inherited members keep their declaring symbol, so an
+// object type declared in one file registers the base-interface or base-class
+// files its properties actually come from.
+func metadataCollection_touchProperties(checker *nativechecker.Checker, symbols []*nativeast.Symbol) []*nativeast.Symbol {
+  for _, symbol := range symbols {
+    MetadataDependency_touchSymbol(checker, symbol)
+  }
+  return symbols
+}
+
 func (collection *MetadataCollection) IndexInfos(checker *nativechecker.Checker, typ *nativechecker.Type) []*nativechecker.IndexInfo {
   if collection == nil {
     return nativechecker.Checker_getIndexInfosOfType(checker, typ)
@@ -297,22 +314,70 @@ func (collection *MetadataCollection) getName(checker *nativechecker.Checker, ty
   if collection.Options != nil && collection.Options.Replace != nil {
     name = collection.Options.Replace(name)
   }
-  duplicates := collection.names_[name]
-  if duplicates == nil {
-    duplicates = map[*nativechecker.Type]string{}
-    collection.names_[name] = duplicates
-  }
-  if oldbie, ok := duplicates[typ]; ok {
+  if oldbie, ok := collection.names_[typ]; ok {
     return oldbie, display
   }
-  addicted := name
-  if len(duplicates) != 0 {
-    addicted = name + ".o" + metadataCollection_itoa(len(duplicates))
-  }
-  duplicates[typ] = addicted
+  addicted, index := metadataCollection_allocateName(
+    collection.allocated_names_,
+    name,
+    collection.name_counters_[name],
+  )
+  collection.allocated_names_[addicted] = true
+  collection.name_counters_[name] = index + 1
+  collection.names_[typ] = addicted
   return addicted, display
 }
 
+// metadataCollection_duplicateSuffix separates a duplicated base name from its
+// disambiguating counter.
+//
+// It must not be ".", which is how a qualified name separates a namespace from
+// its member. Two consumers read that meaning back out of an allocated id:
+// `JsonDescriptor.cascade` inherits the prefix component's description into the
+// child, and a reader of `reflect.name` sees a member of a namespace that never
+// declared it. A dotted counter also let an invented id land on the real full
+// name of a `namespace Foo { interface o1 }` member, and the loser was dropped
+// from the document outright. "-" cannot occur in a qualified name, is in the
+// OpenAPI Components Object key alphabet, and needs no JSON Pointer or URI
+// escaping; `metadataCollection_openApiNameSuffix` picks it for the same reason.
+const metadataCollection_duplicateSuffix = "-o"
+
+// metadataCollection_allocateName mints the first id at or after `from` that no
+// other type in the collection has already been given, and reports the counter
+// it settled on.
+//
+// `taken` is the whole collection's allocated-id set, not one base name's
+// bucket. Bucketing by base name alone cannot see that another base name
+// already minted, or genuinely owns, the id being handed out, so two distinct
+// types received one id and one of them silently disappeared from every
+// generated document. Consulting the whole set is what makes an id unique; the
+// separator only keeps that id from being *read* as something it is not.
+//
+// `from` is the caller's per-base-name counter and is an optimization, never
+// the uniqueness argument: the set is still checked, so a wrong `from` costs a
+// scan rather than a collision. It exists because every anonymous type shares
+// the name `__type`. Always starting at zero rescans the whole run of previous
+// `__type` ids for each new one, which is quadratic in a program's anonymous
+// type count and cost 87s at 20k where resuming costs milliseconds.
+func metadataCollection_allocateName(taken map[string]bool, name string, from int) (string, int) {
+  index := from
+  allocated := metadataCollection_composeName(name, index)
+  for taken[allocated] {
+    index++
+    allocated = metadataCollection_composeName(name, index)
+  }
+  return allocated, index
+}
+
+// metadataCollection_composeName renders a base name at a counter. Counter zero
+// is the base name itself, so the first type of a name keeps it unchanged.
+func metadataCollection_composeName(name string, index int) string {
+  if index == 0 {
+    return name
+  }
+  return name + metadataCollection_duplicateSuffix + metadataCollection_itoa(index)
+}
+
 func (collection *MetadataCollection) getFullName(checker *nativechecker.Checker, typ *nativechecker.Type) string {
   fullName, ok := collection.full_names_[typ]
   if ok == false {
@@ -330,7 +395,7 @@ func (collection *MetadataCollection) getFullName(checker *nativechecker.Checker
 // getDisplayName renders the structural form (checker.TypeToString) of types
 // whose sanitized identifier name carries the anonymous "__type" marker, so
 // human-facing expected strings can show `{ id: string; name: string; }`
-// instead of `__type.o1`. Named types return "": their identifier name is
+// instead of `__type-o1`. Named types return "": their identifier name is
 // already the best display, and so is the degenerate case where the rendering
 // brings no extra information.
 func (collection *MetadataCollection) getDisplayName(checker *nativechecker.Checker, typ *nativechecker.Type, sanitized string) string {
@@ -534,6 +599,191 @@ func MetadataCollection_replace(str string) string {
   return str
 }
 
+// metadataCollection_qualifyOpenApiName keeps the dots of a type's own
+// namespace qualification and rewrites every other dot in a rendered name.
+//
+// A dot in a Components Object key is read back as a namespace boundary:
+// `JsonDescriptor.cascade` looks the dotted prefix up as a component and
+// inherits its description into the child. Deleting a rendered name's angle
+// brackets flattens a nested type into the key and used to leave that nested
+// type's dots behind, so `Gen<Ns.Inner>` became `GenNs.Inner` and claimed the
+// unrelated `GenNs` interface as its parent. The dots of a nested rendering —
+// a type argument, a union member — belong to the nested type, never to the
+// whole.
+//
+// Only the leading run of identifier runes is the type's own name, because
+// `metadataCollection_exploreName` builds exactly that prefix from the
+// declaration's enclosing module blocks. Once a structural rune appears the
+// rendering has descended into another type, so no later dot can be this type's
+// namespace boundary.
+//
+// This owns the OpenAPI key space alone. Deliberately not `MetadataCollection_replace`:
+// the LLM `$defs` and `reflect.name` key spaces carry no namespace meaning, and
+// no consumer reads a parent relation out of them.
+func metadataCollection_qualifyOpenApiName(str string) string {
+  var builder strings.Builder
+  qualified := true
+  for _, ch := range str {
+    if ch == '.' {
+      if qualified {
+        builder.WriteRune('.')
+      } else {
+        builder.WriteString(metadataCollection_qualifySeparator)
+      }
+      continue
+    }
+    if metadataCollection_isIdentifierRune(ch) == false {
+      qualified = false
+    }
+    builder.WriteRune(ch)
+  }
+  return builder.String()
+}
+
+// metadataCollection_qualifySeparator renders a flattened nested type's
+// boundary. "-" is in the OpenAPI key alphabet and cannot occur in a qualified
+// name, so it can never be mistaken for the namespace boundary a dot denotes.
+//
+// A quoted literal argument can contain "-" of its own, so this alone is not
+// injective; `metadataCollection_writeOpenApiQuotedRune` is what keeps a
+// literal dot from colliding with it, and `metadataCollection_allocateName`
+// bounds whatever remains.
+const metadataCollection_qualifySeparator = "-"
+
+// metadataCollection_isIdentifierRune reports whether a rune can appear in a
+// TypeScript identifier, and therefore in a qualified name. Unicode letters
+// count: `Café.Member` is a real qualification whose dot must survive, even
+// though the final key escapes the accented rune.
+func metadataCollection_isIdentifierRune(ch rune) bool {
+  return unicode.IsLetter(ch) ||
+    unicode.IsDigit(ch) ||
+    ch == '_' ||
+    ch == '$'
+}
+
+// MetadataCollection_replaceOpenApi converts a metadata display name into an
+// OpenAPI Components Object key. Keep this separate from the general metadata
+// replacement used by LLM `$defs`, for two reasons. OpenAPI restricts keys to
+// an ASCII grammar, while an LLM definition map can own arbitrary JSON object
+// keys. And an OpenAPI key is structure a consumer reads back — a dot in one is
+// a namespace boundary to `JsonDescriptor.cascade` — so this replacer also owes
+// `metadataCollection_qualifyOpenApiName`'s rule, which an LLM key does not.
+func MetadataCollection_replaceOpenApi(str string) string {
+  var escaped strings.Builder
+  var quote rune
+  quotedContent := false
+  quotedEscape := false
+  disambiguate := false
+  for _, ch := range str {
+    if quote != 0 {
+      if quotedEscape {
+        disambiguate = metadataCollection_writeOpenApiQuotedRune(&escaped, ch) || disambiguate
+        quotedContent = true
+        quotedEscape = false
+        continue
+      }
+      if ch == '\\' {
+        disambiguate = metadataCollection_writeOpenApiQuotedRune(&escaped, ch) || disambiguate
+        quotedContent = true
+        quotedEscape = true
+        continue
+      }
+      if ch == quote {
+        if quotedContent == false {
+          disambiguate = true
+        }
+        quote = 0
+        continue
+      }
+      disambiguate = metadataCollection_writeOpenApiQuotedRune(&escaped, ch) || disambiguate
+      quotedContent = true
+      continue
+    }
+    if ch == '\'' || ch == '"' || ch == '`' {
+      quote = ch
+      quotedContent = false
+      continue
+    }
+    if ch == '$' {
+      disambiguate = metadataCollection_writeOpenApiNameRune(&escaped, ch) || disambiguate
+    } else {
+      escaped.WriteRune(ch)
+    }
+  }
+  normalized := MetadataCollection_replace(metadataCollection_qualifyOpenApiName(escaped.String()))
+  if len(normalized) == 0 {
+    normalized = "_"
+    disambiguate = true
+  }
+  var builder strings.Builder
+  for _, ch := range normalized {
+    disambiguate = metadataCollection_writeOpenApiNameRune(&builder, ch) || disambiguate
+  }
+  if disambiguate {
+    builder.WriteString(metadataCollection_openApiNameSuffix)
+    builder.WriteString(metadataCollection_openApiNameHash(str))
+  }
+  return builder.String()
+}
+
+// metadataCollection_openApiNameSuffix separates an escaped base name from its
+// disambiguating hash. It must not be ".": JsonDescriptor.cascade reads a dot
+// in a component key as a namespace boundary and inherits the parent
+// component's description, so a dotted suffix would present the escaped base as
+// a fake parent and pull an unrelated type's description into the escaped
+// schema. "-" is in the OpenAPI key alphabet, needs no JSON Pointer or URI
+// escaping, and carries no such meaning.
+const metadataCollection_openApiNameSuffix = "-x"
+
+func metadataCollection_writeOpenApiNameRune(builder *strings.Builder, ch rune) bool {
+  if metadataCollection_isOpenApiNameRune(ch) {
+    builder.WriteRune(ch)
+    return false
+  }
+  metadataCollection_writeOpenApiEscapedRune(builder, ch)
+  return true
+}
+
+// metadataCollection_writeOpenApiQuotedRune writes one rune of a quoted literal
+// type argument, such as the `A.B` of `Recursive<"A.B">`.
+//
+// A dot inside a quote is literal content, never the namespace boundary a
+// component key's dot denotes, so it is escaped like every other rune the key
+// alphabet cannot carry unaltered. Escaping is also what keeps the rewrite
+// injective: an escaped name earns the disambiguating hash of its original
+// text, so `Recursive<"A.B">` can neither collide with the `Recursive<"A-B">`
+// that `metadataCollection_qualifySeparator` would otherwise have shared, nor
+// squat the name `Recursive<"A_x2E_B">` legally owns.
+func metadataCollection_writeOpenApiQuotedRune(builder *strings.Builder, ch rune) bool {
+  if ch == '.' {
+    metadataCollection_writeOpenApiEscapedRune(builder, ch)
+    return true
+  }
+  return metadataCollection_writeOpenApiNameRune(builder, ch)
+}
+
+func metadataCollection_writeOpenApiEscapedRune(builder *strings.Builder, ch rune) {
+  builder.WriteString("_x")
+  builder.WriteString(strings.ToUpper(strconv.FormatInt(int64(ch), 16)))
+  builder.WriteByte('_')
+}
+
+func metadataCollection_openApiNameHash(str string) string {
+  hasher := fnv.New64a()
+  _, _ = hasher.Write([]byte(str))
+  encoded := strings.ToUpper(strconv.FormatUint(hasher.Sum64(), 16))
+  return strings.Repeat("0", 16-len(encoded)) + encoded
+}
+
+func metadataCollection_isOpenApiNameRune(ch rune) bool {
+  return (ch >= 'a' && ch <= 'z') ||
+    (ch >= 'A' && ch <= 'Z') ||
+    (ch >= '0' && ch <= '9') ||
+    ch == '.' ||
+    ch == '-' ||
+    ch == '_'
+}
+
 func MetadataCollection_escape(str string) string {
   for _, pair := range metadataCollection_replacers {
     if pair.After != "" {