typia 15.0.0 → 15.1.0

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

@@ -5,6 +5,13 @@ import (
   schemametadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
 )
 
+// Iterate_metadata_atomic records boolean, number, bigint and string types and
+// their literal forms as one atomic of the matching kind.
+//
+// @evidence contracts/common.md#principled-implementation The checker's type flags for boolean-like, number-like, bigint-like and string-like types, and their literal forms, select one atomic kind from a fixed table, and the atomic is added once per kind.
+// @evidence contracts/common.md#clear-and-simple-design One function over a four-row table.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts The table is the language's primitive categories.
+// @evidence contracts/common.md#meaningful-documentation The doc states the four kinds.
 func Iterate_metadata_atomic(props struct {
   Metadata *schemametadata.MetadataSchema
   Type     *nativechecker.Type

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

@@ -5,6 +5,14 @@ import (
   schemametadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
 )
 
+// Iterate_metadata_coalesce handles the types that set a flag instead of a
+// bucket: unknown and any set Any, null sets Nullable, and undefined, never and
+// void make the schema not required.
+//
+// @evidence contracts/common.md#principled-implementation Types that add no bucket are expressed as flags: unknown and any make the schema Any, null makes it Nullable, and undefined, never and void clear Required, so the schema's union members only describe real values.
+// @evidence contracts/common.md#clear-and-simple-design One function of three flag tests.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts The tests are the checker's flags.
+// @evidence contracts/common.md#meaningful-documentation The doc states the three flag effects.
 func Iterate_metadata_coalesce(props struct {
   Metadata *schemametadata.MetadataSchema
   Type     *nativechecker.Type

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

@@ -2,6 +2,14 @@ package metadata
 
 import schemametadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
 
+// Iterate_metadata_collection finishes a collection after analysis: it marks
+// recursive arrays, tuples and objects and reads comment tags into object
+// properties.
+//
+// @evidence contracts/common.md#principled-implementation After analysis, arrays and tuples are marked recursive by visited-set searches through their supported container edges. Comment tags are applied to object properties before object recursion is marked by strongly connected components: a multi-object component or a self edge is recursive. Array/tuple searches and object-edge collection deliberately stop across already recursive opposite container types rather than traversing every reference edge.
+// @evidence contracts/common.md#clear-and-simple-design One function with private recursion checkers for arrays and tuples and a Tarjan search for objects, which need different edge sets.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts The graph search is a recognized algorithm and no type is named.
+// @evidence contracts/common.md#meaningful-documentation The doc states the marking and the comment tag step.
 func Iterate_metadata_collection(props struct {
   Errors     *[]MetadataFactory_IError
   Collection *schemametadata.MetadataCollection

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

@@ -4,9 +4,9 @@
 package metadata
 
 import (
-	"testing"
+  "testing"
 
-	schemametadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+  schemametadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
 )
 
 // TestIterateMetadataCollectionBranchMatrix covers recursive graph detection.
@@ -20,182 +20,187 @@ import (
 // 2. Exercise direct self-reference and visited/nil guard branches.
 // 3. Walk alias, tuple, array, map, set, escaped, and rest edges for arrays.
 // 4. Walk the same edge families for tuple and object recursion.
+//
+// @evidence contracts/testing.md#behavioral-verification Recursion detection walks authored array, tuple, object, alias, map, set, escaped and rest graphs; flags set on collection types, nil and visited inputs and recursion through each edge kind are asserted.
+// @evidence contracts/testing.md#independent-expectations Graph cycles are constructed by the test, so recursion is a fact of the authored shape rather than an output of the walker.
+// @evidence contracts/testing.md#distinguishing-cases Each edge kind has a recursive graph, plus nil and visited controls; non-recursive graphs for every kind are not all asserted.
+// @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 the internal walkers on constructed graphs with no program load or process.
 func TestIterateMetadataCollectionBranchMatrix(t *testing.T) {
-	collection := schemametadata.NewMetadataCollection()
-	arrayType, _, setArray := collection.EmplaceArray(nil, nil)
-	tupleType, _, setTuple := collection.EmplaceTuple(nil, nil)
-	objectType, _ := collection.Emplace(nil, nil)
-	arrayType.Value = arrayRef(arrayType)
-	setArray(arrayType.Value)
-	tupleType.Elements = []*schemametadata.MetadataSchema{tupleRef(tupleType)}
-	setTuple(tupleType.Elements)
-	objectType.Properties = []*schemametadata.MetadataProperty{
-		schemametadata.MetadataProperty_create(schemametadata.MetadataProperty{
-			Key:   literalMetadata("self"),
-			Value: objectRef(objectType),
-		}),
-	}
-	Iterate_metadata_collection(struct {
-		Errors     *[]MetadataFactory_IError
-		Collection *schemametadata.MetadataCollection
-	}{Collection: collection})
-	if arrayType.Recursive != true || tupleType.Recursive != true || objectType.Recursive != true {
-		t.Fatal("collection recursion flags were not detected")
-	}
-
-	if iterate_metadata_collection_is_array_recursive(struct {
-		Visited  map[*schemametadata.MetadataSchema]bool
-		Array    *schemametadata.MetadataArrayType
-		Metadata *schemametadata.MetadataSchema
-	}{Visited: map[*schemametadata.MetadataSchema]bool{}, Array: arrayType}) {
-		t.Fatal("nil array metadata should not be recursive")
-	}
-	visited := arrayRef(arrayType)
-	if iterate_metadata_collection_is_array_recursive(struct {
-		Visited  map[*schemametadata.MetadataSchema]bool
-		Array    *schemametadata.MetadataArrayType
-		Metadata *schemametadata.MetadataSchema
-	}{Visited: map[*schemametadata.MetadataSchema]bool{visited: true}, Array: arrayType, Metadata: visited}) {
-		t.Fatal("visited array metadata should not recurse again")
-	}
-
-	for _, meta := range []*schemametadata.MetadataSchema{
-		arrayRef(arrayType),
-		aliasTo(arrayRef(arrayType)),
-		tupleOf(arrayRef(arrayType), false),
-		mapValue(arrayRef(arrayType)),
-		setValue(arrayRef(arrayType)),
-		escapedReturns(arrayRef(arrayType)),
-		restOf(arrayRef(arrayType)),
-	} {
-		if !iterate_metadata_collection_is_array_recursive(struct {
-			Visited  map[*schemametadata.MetadataSchema]bool
-			Array    *schemametadata.MetadataArrayType
-			Metadata *schemametadata.MetadataSchema
-		}{Visited: map[*schemametadata.MetadataSchema]bool{}, Array: arrayType, Metadata: meta}) {
-			t.Fatalf("array recursion was not found through %s", meta.GetName())
-		}
-	}
-
-	for _, meta := range []*schemametadata.MetadataSchema{
-		tupleRef(tupleType),
-		tupleOf(tupleRef(tupleType), false),
-		arrayOf(tupleRef(tupleType), false),
-		mapValue(tupleRef(tupleType)),
-		setValue(tupleRef(tupleType)),
-		aliasTo(tupleRef(tupleType)),
-		escapedReturns(tupleRef(tupleType)),
-		restOf(tupleRef(tupleType)),
-	} {
-		if !iterate_metadata_collection_is_tuple_recursive(struct {
-			Visited  map[*schemametadata.MetadataSchema]bool
-			Tuple    *schemametadata.MetadataTupleType
-			Metadata *schemametadata.MetadataSchema
-		}{Visited: map[*schemametadata.MetadataSchema]bool{}, Tuple: tupleType, Metadata: meta}) {
-			t.Fatalf("tuple recursion was not found through %s", meta.GetName())
-		}
-	}
-
-	for _, meta := range []*schemametadata.MetadataSchema{
-		objectRef(objectType),
-		objectWithProperty(objectRef(objectType)),
-		aliasTo(objectRef(objectType)),
-		arrayOf(objectRef(objectType), false),
-		tupleOf(objectRef(objectType), false),
-		mapValue(objectRef(objectType)),
-		setValue(objectRef(objectType)),
-		escapedReturns(objectRef(objectType)),
-		restOf(objectRef(objectType)),
-	} {
-		if !iterate_metadata_collection_is_object_recursive(struct {
-			Visited  map[*schemametadata.MetadataSchema]bool
-			Object   *schemametadata.MetadataObjectType
-			Metadata *schemametadata.MetadataSchema
-		}{Visited: map[*schemametadata.MetadataSchema]bool{}, Object: objectType, Metadata: meta}) {
-			t.Fatalf("object recursion was not found through %s", meta.GetName())
-		}
-	}
+  collection := schemametadata.NewMetadataCollection()
+  arrayType, _, setArray := collection.EmplaceArray(nil, nil)
+  tupleType, _, setTuple := collection.EmplaceTuple(nil, nil)
+  objectType, _ := collection.Emplace(nil, nil)
+  arrayType.Value = arrayRef(arrayType)
+  setArray(arrayType.Value)
+  tupleType.Elements = []*schemametadata.MetadataSchema{tupleRef(tupleType)}
+  setTuple(tupleType.Elements)
+  objectType.Properties = []*schemametadata.MetadataProperty{
+    schemametadata.MetadataProperty_create(schemametadata.MetadataProperty{
+      Key:   literalMetadata("self"),
+      Value: objectRef(objectType),
+    }),
+  }
+  Iterate_metadata_collection(struct {
+    Errors     *[]MetadataFactory_IError
+    Collection *schemametadata.MetadataCollection
+  }{Collection: collection})
+  if arrayType.Recursive != true || tupleType.Recursive != true || objectType.Recursive != true {
+    t.Fatal("collection recursion flags were not detected")
+  }
+
+  if iterate_metadata_collection_is_array_recursive(struct {
+    Visited  map[*schemametadata.MetadataSchema]bool
+    Array    *schemametadata.MetadataArrayType
+    Metadata *schemametadata.MetadataSchema
+  }{Visited: map[*schemametadata.MetadataSchema]bool{}, Array: arrayType}) {
+    t.Fatal("nil array metadata should not be recursive")
+  }
+  visited := arrayRef(arrayType)
+  if iterate_metadata_collection_is_array_recursive(struct {
+    Visited  map[*schemametadata.MetadataSchema]bool
+    Array    *schemametadata.MetadataArrayType
+    Metadata *schemametadata.MetadataSchema
+  }{Visited: map[*schemametadata.MetadataSchema]bool{visited: true}, Array: arrayType, Metadata: visited}) {
+    t.Fatal("visited array metadata should not recurse again")
+  }
+
+  for _, meta := range []*schemametadata.MetadataSchema{
+    arrayRef(arrayType),
+    aliasTo(arrayRef(arrayType)),
+    tupleOf(arrayRef(arrayType), false),
+    mapValue(arrayRef(arrayType)),
+    setValue(arrayRef(arrayType)),
+    escapedReturns(arrayRef(arrayType)),
+    restOf(arrayRef(arrayType)),
+  } {
+    if !iterate_metadata_collection_is_array_recursive(struct {
+      Visited  map[*schemametadata.MetadataSchema]bool
+      Array    *schemametadata.MetadataArrayType
+      Metadata *schemametadata.MetadataSchema
+    }{Visited: map[*schemametadata.MetadataSchema]bool{}, Array: arrayType, Metadata: meta}) {
+      t.Fatalf("array recursion was not found through %s", meta.GetName())
+    }
+  }
+
+  for _, meta := range []*schemametadata.MetadataSchema{
+    tupleRef(tupleType),
+    tupleOf(tupleRef(tupleType), false),
+    arrayOf(tupleRef(tupleType), false),
+    mapValue(tupleRef(tupleType)),
+    setValue(tupleRef(tupleType)),
+    aliasTo(tupleRef(tupleType)),
+    escapedReturns(tupleRef(tupleType)),
+    restOf(tupleRef(tupleType)),
+  } {
+    if !iterate_metadata_collection_is_tuple_recursive(struct {
+      Visited  map[*schemametadata.MetadataSchema]bool
+      Tuple    *schemametadata.MetadataTupleType
+      Metadata *schemametadata.MetadataSchema
+    }{Visited: map[*schemametadata.MetadataSchema]bool{}, Tuple: tupleType, Metadata: meta}) {
+      t.Fatalf("tuple recursion was not found through %s", meta.GetName())
+    }
+  }
+
+  for _, meta := range []*schemametadata.MetadataSchema{
+    objectRef(objectType),
+    objectWithProperty(objectRef(objectType)),
+    aliasTo(objectRef(objectType)),
+    arrayOf(objectRef(objectType), false),
+    tupleOf(objectRef(objectType), false),
+    mapValue(objectRef(objectType)),
+    setValue(objectRef(objectType)),
+    escapedReturns(objectRef(objectType)),
+    restOf(objectRef(objectType)),
+  } {
+    if !iterate_metadata_collection_is_object_recursive(struct {
+      Visited  map[*schemametadata.MetadataSchema]bool
+      Object   *schemametadata.MetadataObjectType
+      Metadata *schemametadata.MetadataSchema
+    }{Visited: map[*schemametadata.MetadataSchema]bool{}, Object: objectType, Metadata: meta}) {
+      t.Fatalf("object recursion was not found through %s", meta.GetName())
+    }
+  }
 }
 
 func literalMetadata(value string) *schemametadata.MetadataSchema {
-	meta := schemametadata.MetadataSchema_initialize()
-	meta.Constants = append(meta.Constants, schemametadata.MetadataConstant_create(schemametadata.MetadataConstant{
-		Type: "string",
-		Values: []*schemametadata.MetadataConstantValue{
-			schemametadata.MetadataConstantValue_create(schemametadata.MetadataConstantValue{Value: value}),
-		},
-	}))
-	return meta
+  meta := schemametadata.MetadataSchema_initialize()
+  meta.Constants = append(meta.Constants, schemametadata.MetadataConstant_create(schemametadata.MetadataConstant{
+    Type: "string",
+    Values: []*schemametadata.MetadataConstantValue{
+      schemametadata.MetadataConstantValue_create(schemametadata.MetadataConstantValue{Value: value}),
+    },
+  }))
+  return meta
 }
 
 func arrayRef(array *schemametadata.MetadataArrayType) *schemametadata.MetadataSchema {
-	meta := schemametadata.MetadataSchema_initialize()
-	meta.Arrays = append(meta.Arrays, schemametadata.MetadataArray_create(schemametadata.MetadataArray{Type: array}))
-	return meta
+  meta := schemametadata.MetadataSchema_initialize()
+  meta.Arrays = append(meta.Arrays, schemametadata.MetadataArray_create(schemametadata.MetadataArray{Type: array}))
+  return meta
 }
 
 func arrayOf(value *schemametadata.MetadataSchema, recursive bool) *schemametadata.MetadataSchema {
-	array := schemametadata.MetadataArrayType_create(schemametadata.MetadataArrayType{Name: "NestedArray", Value: value, Recursive: recursive})
-	return arrayRef(array)
+  array := schemametadata.MetadataArrayType_create(schemametadata.MetadataArrayType{Name: "NestedArray", Value: value, Recursive: recursive})
+  return arrayRef(array)
 }
 
 func tupleRef(tuple *schemametadata.MetadataTupleType) *schemametadata.MetadataSchema {
-	meta := schemametadata.MetadataSchema_initialize()
-	meta.Tuples = append(meta.Tuples, schemametadata.MetadataTuple_create(schemametadata.MetadataTuple{Type: tuple}))
-	return meta
+  meta := schemametadata.MetadataSchema_initialize()
+  meta.Tuples = append(meta.Tuples, schemametadata.MetadataTuple_create(schemametadata.MetadataTuple{Type: tuple}))
+  return meta
 }
 
 func tupleOf(value *schemametadata.MetadataSchema, recursive bool) *schemametadata.MetadataSchema {
-	tuple := schemametadata.MetadataTupleType_create(schemametadata.MetadataTupleType{Name: "NestedTuple", Elements: []*schemametadata.MetadataSchema{value}, Recursive: recursive})
-	return tupleRef(tuple)
+  tuple := schemametadata.MetadataTupleType_create(schemametadata.MetadataTupleType{Name: "NestedTuple", Elements: []*schemametadata.MetadataSchema{value}, Recursive: recursive})
+  return tupleRef(tuple)
 }
 
 func objectRef(object *schemametadata.MetadataObjectType) *schemametadata.MetadataSchema {
-	meta := schemametadata.MetadataSchema_initialize()
-	meta.Objects = append(meta.Objects, schemametadata.MetadataObject_create(schemametadata.MetadataObject{Type: object}))
-	return meta
+  meta := schemametadata.MetadataSchema_initialize()
+  meta.Objects = append(meta.Objects, schemametadata.MetadataObject_create(schemametadata.MetadataObject{Type: object}))
+  return meta
 }
 
 func objectWithProperty(value *schemametadata.MetadataSchema) *schemametadata.MetadataSchema {
-	object := schemametadata.MetadataObjectType_create(schemametadata.MetadataObjectType{
-		Name: "NestedObject",
-		Properties: []*schemametadata.MetadataProperty{
-			schemametadata.MetadataProperty_create(schemametadata.MetadataProperty{Key: literalMetadata("value"), Value: value}),
-		},
-	})
-	return objectRef(object)
+  object := schemametadata.MetadataObjectType_create(schemametadata.MetadataObjectType{
+    Name: "NestedObject",
+    Properties: []*schemametadata.MetadataProperty{
+      schemametadata.MetadataProperty_create(schemametadata.MetadataProperty{Key: literalMetadata("value"), Value: value}),
+    },
+  })
+  return objectRef(object)
 }
 
 func aliasTo(value *schemametadata.MetadataSchema) *schemametadata.MetadataSchema {
-	alias := schemametadata.MetadataAliasType_create(schemametadata.MetadataAliasType{Name: "Alias", Value: value})
-	meta := schemametadata.MetadataSchema_initialize()
-	meta.Aliases = append(meta.Aliases, schemametadata.MetadataAlias_create(schemametadata.MetadataAlias{Type: alias}))
-	return meta
+  alias := schemametadata.MetadataAliasType_create(schemametadata.MetadataAliasType{Name: "Alias", Value: value})
+  meta := schemametadata.MetadataSchema_initialize()
+  meta.Aliases = append(meta.Aliases, schemametadata.MetadataAlias_create(schemametadata.MetadataAlias{Type: alias}))
+  return meta
 }
 
 func mapValue(value *schemametadata.MetadataSchema) *schemametadata.MetadataSchema {
-	meta := schemametadata.MetadataSchema_initialize()
-	meta.Maps = append(meta.Maps, schemametadata.MetadataMap_create(schemametadata.MetadataMap{Key: literalMetadata("key"), Value: value}))
-	return meta
+  meta := schemametadata.MetadataSchema_initialize()
+  meta.Maps = append(meta.Maps, schemametadata.MetadataMap_create(schemametadata.MetadataMap{Key: literalMetadata("key"), Value: value}))
+  return meta
 }
 
 func setValue(value *schemametadata.MetadataSchema) *schemametadata.MetadataSchema {
-	meta := schemametadata.MetadataSchema_initialize()
-	meta.Sets = append(meta.Sets, schemametadata.MetadataSet_create(schemametadata.MetadataSet{Value: value}))
-	return meta
+  meta := schemametadata.MetadataSchema_initialize()
+  meta.Sets = append(meta.Sets, schemametadata.MetadataSet_create(schemametadata.MetadataSet{Value: value}))
+  return meta
 }
 
 func escapedReturns(value *schemametadata.MetadataSchema) *schemametadata.MetadataSchema {
-	meta := schemametadata.MetadataSchema_initialize()
-	meta.Escaped = schemametadata.MetadataEscaped_create(schemametadata.MetadataEscaped{
-		Original: literalMetadata("source"),
-		Returns:  value,
-	})
-	return meta
+  meta := schemametadata.MetadataSchema_initialize()
+  meta.Escaped = schemametadata.MetadataEscaped_create(schemametadata.MetadataEscaped{
+    Original: literalMetadata("source"),
+    Returns:  value,
+  })
+  return meta
 }
 
 func restOf(value *schemametadata.MetadataSchema) *schemametadata.MetadataSchema {
-	meta := schemametadata.MetadataSchema_initialize()
-	meta.Rest = value
-	return meta
+  meta := schemametadata.MetadataSchema_initialize()
+  meta.Rest = value
+  return meta
 }

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

@@ -2,6 +2,13 @@ package metadata
 
 import schemametadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
 
+// Iterate_metadata_comment_tags applies the JSDoc tags of each property of an
+// object to the property's metadata, once per object.
+//
+// @evidence contracts/common.md#principled-implementation Each property that has JSDoc tags passes them to the comment tag analyzer with its location, and the object is marked tagged first so the pass runs once even if the object is reached again; the analyzer is a package variable that the tag factory installs, which avoids an import cycle.
+// @evidence contracts/common.md#clear-and-simple-design One function with an early return for no analyzer.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts Installing the analyzer through a package variable is a dependency inversion and not a monkey patch of foreign code.
+// @evidence contracts/common.md#meaningful-documentation The doc states the once-per-object rule.
 func Iterate_metadata_comment_tags(props struct {
   Errors *[]MetadataFactory_IError
   Object *schemametadata.MetadataObjectType

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

@@ -4,10 +4,21 @@ import (
   "fmt"
   "strconv"
 
+  nativeast "github.com/microsoft/typescript-go/shim/ast"
   nativechecker "github.com/microsoft/typescript-go/shim/checker"
   schemametadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
 )
 
+// Iterate_metadata_constant records string, number, bigint and boolean literal
+// types as constants when the Constant option is on.
+//
+// Enum members keep their documentation, and a value that two constituents list
+// is folded into the first and marked duplicated.
+//
+// @evidence contracts/common.md#principled-implementation When constants are enabled, a string, number or bigint literal becomes a constant value of that type, a bigint is normalized to a comparable text value and a boolean literal is read from the checker's printed type; enum members keep their documentation, and two constituents with the same value are folded into one with a duplicated mark because the second member's documentation cannot be reached from the type, which the enum-sharing helper detects by scanning the enum declarations.
+// @evidence contracts/common.md#clear-and-simple-design One function with small helpers for taking a constant bucket, adding with folding, keying values and detecting shared enum values.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts The fold and its loss of documentation are stated limits and not hidden.
+// @evidence contracts/common.md#meaningful-documentation The doc states the option gate and the fold rule.
 func Iterate_metadata_constant(props IMetadataIteratorProps) bool {
   if props.Options.Constant == false {
     return false
@@ -61,6 +72,7 @@ func Iterate_metadata_constant(props IMetadataIteratorProps) bool {
       Tags:        [][]schemametadata.IMetadataTypeTag{},
       Description: info.description,
       JsDocTags:   info.jsDocTags,
+      Duplicated:  filter(nativechecker.TypeFlagsEnumLiteral) && iterate_metadata_constant_shared(props.Checker, props.Type),
     }))
     return true
   }
@@ -100,6 +112,12 @@ func iterate_metadata_constant_add(constant *schemametadata.MetadataConstant, va
   key := iterate_metadata_constant_key(value.Value)
   for _, oldbie := range constant.Values {
     if iterate_metadata_constant_key(oldbie.Value) == key {
+      // A union lists one value through two constituents (an enum member and
+      // a literal, or a literal with and without a type tag), so the second
+      // folds into the first and its documentation and requirements are lost.
+      // TypeScript already deduplicates identical types, so this is never the
+      // same declaration twice.
+      oldbie.Duplicated = true
       return
     }
   }
@@ -140,3 +158,53 @@ func iterate_metadata_constant_key(value any) string {
     return fmt.Sprint(value)
   }
 }
+
+// iterate_metadata_constant_shared reports whether an enum literal type stands
+// for several members of its enum. TypeScript gives members with one value a
+// single literal type, so the second member's documentation is unreachable
+// from the type and the only witness is the enum declaration.
+func iterate_metadata_constant_shared(checker *nativechecker.Checker, typ *nativechecker.Type) bool {
+  if checker == nil || typ == nil {
+    return false
+  }
+  symbol := typ.Symbol()
+  if symbol == nil || len(symbol.Declarations) == 0 {
+    return false
+  }
+  declaration := symbol.Declarations[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
+  }
+  // compare by value: a member's own type may be the fresh form of the
+  // regular literal type the union holds
+  value := iterate_metadata_constant_key(typ.AsLiteralType().Value())
+  count := 0
+  for _, each := range declarations {
+    if each == nil || each.Kind != nativeast.KindEnumDeclaration {
+      continue
+    }
+    enum := each.AsEnumDeclaration()
+    if enum == nil || enum.Members == nil {
+      continue
+    }
+    for _, member := range enum.Members.Nodes {
+      if member == nil || member.Symbol() == nil {
+        continue
+      }
+      memberType := checker.GetTypeOfSymbol(member.Symbol())
+      if memberType == nil || memberType.Flags()&nativechecker.TypeFlagsEnumLiteral == 0 || memberType.Flags()&(nativechecker.TypeFlagsStringLiteral|nativechecker.TypeFlagsNumberLiteral) == 0 {
+        continue
+      }
+      if iterate_metadata_constant_key(memberType.AsLiteralType().Value()) == value {
+        count++
+      }
+    }
+  }
+  return count > 1
+}

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

@@ -5,6 +5,13 @@ import (
   schemametadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
 )
 
+// Iterate_metadata_escape records a type with a `toJSON` method as an escaped
+// schema holding both the original type and the method's return type.
+//
+// @evidence contracts/common.md#principled-implementation A type whose class has a `toJSON` method serializes as that method's return type, so the schema records both the original type and the return type as an escaped pair, each explored with the escaped state so they are not escaped again.
+// @evidence contracts/common.md#clear-and-simple-design One function that explores two types into one escaped record.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts The method name is the JSON protocol's.
+// @evidence contracts/common.md#meaningful-documentation The doc states the two halves.
 func Iterate_metadata_escape(props IMetadataIteratorProps) bool {
   if props.Options.Escape == false || props.Explore.Escaped == true {
     return false

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

@@ -1,11 +1,21 @@
 package metadata
 
 import (
+  nativeast "github.com/microsoft/typescript-go/shim/ast"
   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"
 )
 
+// Iterate_metadata_function records callable value identity or the selected
+// signature's parameter and return metadata, according to Functional.
+// Argument omission belongs to the selected formal declaration, independently
+// of the variable's narrowed type inside its body.
+//
+// @evidence contracts/common.md#principled-implementation The checker supplies the existing first callable signature and inferred return type; the global Promise resolver separates asynchronous output. Selected parameter declarations supply question/default omission even when any/unknown erase undefined unions, and independent roots preserve required neighbors in the exploration cache.
+// @evidence contracts/common.md#clear-and-simple-design Function recognition, signature analysis and output exploration remain in one iterator; declaration lookup avoids receiver indexing and implementation-only overload defaults. WithOptional owns root isolation and derived-name invalidation, while Explore_metadata owns shared type exploration.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts The omission decision follows native selected declarations without rewriting foreign symbols, disabling type caches or recognizing fixture names. Nonfunctional analysis retains its callable marker; the existing first-signature policy is not expanded into overload enumeration.
+// @evidence contracts/common.md#meaningful-documentation The native comment distinguishes callable identity from full signature analysis and explains why argument omission differs from the local variable type. The receiver/overload comment states the declaration-identity constraint at its use.
 func Iterate_metadata_function(props IMetadataIteratorProps) bool {
   declaration := metadata_get_function_node(props.Checker, props.Type)
   if declaration == nil {
@@ -46,17 +56,30 @@ func Iterate_metadata_function(props IMetadataIteratorProps) bool {
     explore := props.Explore
     explore.Top = false
     explore.Parameter = p.Name
+    metadata := Explore_metadata(Explore_metadata_IProps{
+      Options:     props.Options,
+      Checker:     props.Checker,
+      Components:  props.Components,
+      Errors:      props.Errors,
+      Type:        paramType,
+      Explore:     explore,
+      Intersected: false,
+    })
+    // Read the selected signature, not an overload implementation or a
+    // contextual arrow's body. Symbol declarations also avoid indexing past
+    // an explicit `this` parameter, which is absent from signature.Parameters.
+    for _, node := range metadata_node_declarations(p) {
+      if node.Kind == nativeast.KindParameter && node.Parent == signature.Declaration() {
+        parameter := node.AsParameterDeclaration()
+        if parameter.QuestionToken != nil || parameter.Initializer != nil {
+          metadata = metadata.WithOptional(true)
+        }
+        break
+      }
+    }
     parameters = append(parameters, schemametadata.MetadataParameter_create(schemametadata.MetadataParameter{
-      Name: p.Name,
-      Type: Explore_metadata(Explore_metadata_IProps{
-        Options:     props.Options,
-        Checker:     props.Checker,
-        Components:  props.Components,
-        Errors:      props.Errors,
-        Type:        paramType,
-        Explore:     explore,
-        Intersected: false,
-      }),
+      Name:        p.Name,
+      Type:        metadata,
       TsType:      paramType,
       Description: metadata_node_description(p),
       JsDocTags:   metadata_node_js_doc_tags(p),