typia 13.1.19 → 13.2.0

package/native/core/programmers/iterate/iterate_utility_coverage_test.go

@@ -4,12 +4,10 @@
 package iterate
 
 import (
-	"math/big"
-	"testing"
+  "math/big"
+  "testing"
 
-	shimast "github.com/microsoft/typescript-go/shim/ast"
-	nativehelpers "github.com/samchon/typia/packages/typia/native/core/programmers/helpers"
-	nativemetadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+  nativemetadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
 )
 
 // TestIterateUtilityCoverage exercises schema and stringify helpers.
@@ -25,278 +23,241 @@ import (
 // 4. Build prune and native stringify statements for object metadata.
 // 5. Build full JSON schema station outputs for empty, any, native, and union metadata.
 func TestIterateUtilityCoverage(t *testing.T) {
-	schema := json_schema_jsDocTags(JsonSchema{}, []nativemetadata.IJsDocTagInfo{
-		{Name: "x-enabled", Text: []nativemetadata.IJsDocTagInfo_IText{{Kind: "text", Text: "true"}}},
-		{Name: "x-count", Text: []nativemetadata.IJsDocTagInfo_IText{{Kind: "text", Text: "3.5"}}},
-		{Name: "x-null", Text: []nativemetadata.IJsDocTagInfo_IText{{Kind: "text", Text: "null"}}},
-		{Name: "description", Text: []nativemetadata.IJsDocTagInfo_IText{{Kind: "text", Text: "ignored"}}},
-	})
-	if schema["x-enabled"] != true || schema["x-count"] != 3.5 {
-		t.Fatal("JSDoc tag casting failed")
-	}
-	if _, ok := json_schema_jsDocTags_value(nativemetadata.IJsDocTagInfo{Name: "x-empty"}); ok {
-		t.Fatal("empty JSDoc tag should not produce a value")
-	}
-	if json_schema_jsDocTags_cast("false") != false ||
-		json_schema_jsDocTags_cast("text") != "text" {
-		t.Fatal("JSDoc tag scalar casting mismatch")
-	}
-	fallbackDescription := "fallback"
-	if title := json_schema_title(struct {
-		description *string
-		jsDocTags   []nativemetadata.IJsDocTagInfo
-	}{
-		jsDocTags: []nativemetadata.IJsDocTagInfo{
-			{Name: "description", Text: []nativemetadata.IJsDocTagInfo_IText{{Text: "ignored"}}},
-			{Name: "title", Text: []nativemetadata.IJsDocTagInfo_IText{{Text: "Line\r\n"}, {Text: "Two"}}},
-		},
-	}); title == nil || *title != "Line\nTwo" {
-		t.Fatal("JSON schema title helper failed")
-	}
-	if description := json_schema_description(struct {
-		description *string
-		jsDocTags   []nativemetadata.IJsDocTagInfo
-	}{
-		description: &fallbackDescription,
-		jsDocTags: []nativemetadata.IJsDocTagInfo{
-			{Name: "description", Text: []nativemetadata.IJsDocTagInfo_IText{{Text: "Doc\r\nText"}}},
-		},
-	}); description == nil || *description != "Doc\nText" {
-		t.Fatal("JSON schema description helper failed")
-	}
-	if description := json_schema_description(struct {
-		description *string
-		jsDocTags   []nativemetadata.IJsDocTagInfo
-	}{description: &fallbackDescription}); description != &fallbackDescription {
-		t.Fatal("JSON schema description fallback failed")
-	}
-	bigValue := big.NewInt(12)
-	if json_schema_constant_value(*bigValue) != float64(12) ||
-		json_schema_constant_value(bigValue) != float64(12) {
-		t.Fatal("JSON schema bigint constant conversion failed")
-	}
+  schema := json_schema_jsDocTags(JsonSchema{}, []nativemetadata.IJsDocTagInfo{
+    {Name: "x-enabled", Text: []nativemetadata.IJsDocTagInfo_IText{{Kind: "text", Text: "true"}}},
+    {Name: "x-count", Text: []nativemetadata.IJsDocTagInfo_IText{{Kind: "text", Text: "3.5"}}},
+    {Name: "x-null", Text: []nativemetadata.IJsDocTagInfo_IText{{Kind: "text", Text: "null"}}},
+    {Name: "description", Text: []nativemetadata.IJsDocTagInfo_IText{{Kind: "text", Text: "ignored"}}},
+  })
+  if schema["x-enabled"] != true || schema["x-count"] != 3.5 {
+    t.Fatal("JSDoc tag casting failed")
+  }
+  if _, ok := json_schema_jsDocTags_value(nativemetadata.IJsDocTagInfo{Name: "x-empty"}); ok {
+    t.Fatal("empty JSDoc tag should not produce a value")
+  }
+  if json_schema_jsDocTags_cast("false") != false ||
+    json_schema_jsDocTags_cast("text") != "text" {
+    t.Fatal("JSDoc tag scalar casting mismatch")
+  }
+  fallbackDescription := "fallback"
+  if title := json_schema_title(struct {
+    description *string
+    jsDocTags   []nativemetadata.IJsDocTagInfo
+  }{
+    jsDocTags: []nativemetadata.IJsDocTagInfo{
+      {Name: "description", Text: []nativemetadata.IJsDocTagInfo_IText{{Text: "ignored"}}},
+      {Name: "title", Text: []nativemetadata.IJsDocTagInfo_IText{{Text: "Line\r\n"}, {Text: "Two"}}},
+    },
+  }); title == nil || *title != "Line\nTwo" {
+    t.Fatal("JSON schema title helper failed")
+  }
+  if description := json_schema_description(struct {
+    description *string
+    jsDocTags   []nativemetadata.IJsDocTagInfo
+  }{
+    description: &fallbackDescription,
+    jsDocTags: []nativemetadata.IJsDocTagInfo{
+      {Name: "description", Text: []nativemetadata.IJsDocTagInfo_IText{{Text: "Doc\r\nText"}}},
+    },
+  }); description == nil || *description != "Doc\nText" {
+    t.Fatal("JSON schema description helper failed")
+  }
+  if description := json_schema_description(struct {
+    description *string
+    jsDocTags   []nativemetadata.IJsDocTagInfo
+  }{description: &fallbackDescription}); description != &fallbackDescription {
+    t.Fatal("JSON schema description fallback failed")
+  }
+  bigValue := big.NewInt(12)
+  if json_schema_constant_value(*bigValue) != float64(12) ||
+    json_schema_constant_value(bigValue) != float64(12) {
+    t.Fatal("JSON schema bigint constant conversion failed")
+  }
 
-	literal := iterateLiteral("fixed")
-	stringMeta := iterateAtomic("string")
-	constantDescription := "constant"
-	constantSchemas := json_schema_constant(nativemetadata.MetadataConstant_create(nativemetadata.MetadataConstant{
-		Type: "bigint",
-		Values: []*nativemetadata.MetadataConstantValue{
-			nativemetadata.MetadataConstantValue_create(nativemetadata.MetadataConstantValue{
-				Value:       big.NewInt(13),
-				Description: &constantDescription,
-				JsDocTags: []nativemetadata.IJsDocTagInfo{
-					{Name: "title", Text: []nativemetadata.IJsDocTagInfo_IText{{Text: "Big"}}},
-				},
-			}),
-		},
-	}))
-	if len(constantSchemas) != 1 || constantSchemas[0]["const"] != float64(13) {
-		t.Fatal("JSON schema constant export failed")
-	}
-	dateMeta := nativemetadata.MetadataSchema_initialize()
-	dateMeta.Natives = append(dateMeta.Natives, nativemetadata.MetadataNative_create(nativemetadata.MetadataNative{Name: "Date"}))
-	arrayDate := nativemetadata.MetadataSchema_initialize()
-	arrayDate.Arrays = append(arrayDate.Arrays, nativemetadata.MetadataArray_create(nativemetadata.MetadataArray{
-		Type: nativemetadata.MetadataArrayType_create(nativemetadata.MetadataArrayType{
-			Name:      "Date[]",
-			Value:     dateMeta,
-			Nullables: []bool{},
-		}),
-	}))
-	aliasDate := nativemetadata.MetadataSchema_initialize()
-	aliasDate.Aliases = append(aliasDate.Aliases, nativemetadata.MetadataAlias_create(nativemetadata.MetadataAlias{
-		Type: nativemetadata.MetadataAliasType_create(nativemetadata.MetadataAliasType{Name: "AliasDate", Value: arrayDate}),
-	}))
-	if !json_schema_escaped_is_date(map[*nativemetadata.MetadataSchema]bool{}, aliasDate) ||
-		json_schema_escaped_is_date(map[*nativemetadata.MetadataSchema]bool{aliasDate: true}, aliasDate) {
-		t.Fatal("JSON schema escaped date recursion failed")
-	}
-	if len(json_schema_escaped(struct {
-		components *OpenApi_IComponents
-		escaped    *nativemetadata.MetadataEscaped
-	}{
-		components: &OpenApi_IComponents{},
-		escaped: nativemetadata.MetadataEscaped_create(nativemetadata.MetadataEscaped{
-			Original: dateMeta,
-			Returns:  stringMeta,
-		}),
-	})) == 0 {
-		t.Fatal("JSON schema escaped export returned empty schemas")
-	}
-	taggedTemplate := nativemetadata.MetadataTemplate_create(nativemetadata.MetadataTemplate{
-		Row: []*nativemetadata.MetadataSchema{literal, stringMeta},
-		Tags: [][]nativemetadata.IMetadataTypeTag{{
-			{Name: "MinLength<1>", Kind: "minLength", Schema: map[string]any{"minLength": 1}},
-		}},
-	})
-	templateMeta := nativemetadata.MetadataSchema_initialize()
-	templateMeta.Templates = append(templateMeta.Templates,
-		nativemetadata.MetadataTemplate_create(nativemetadata.MetadataTemplate{Row: []*nativemetadata.MetadataSchema{literal, stringMeta}}),
-		taggedTemplate,
-	)
-	if len(json_schema_templates(templateMeta)) != 2 ||
-		json_schema_template_isPure(taggedTemplate.Tags) {
-		t.Fatal("template schema helper returned unexpected result")
-	}
+  literal := iterateLiteral("fixed")
+  stringMeta := iterateAtomic("string")
+  constantDescription := "constant"
+  constantSchemas := json_schema_constant(nativemetadata.MetadataConstant_create(nativemetadata.MetadataConstant{
+    Type: "bigint",
+    Values: []*nativemetadata.MetadataConstantValue{
+      nativemetadata.MetadataConstantValue_create(nativemetadata.MetadataConstantValue{
+        Value:       big.NewInt(13),
+        Description: &constantDescription,
+        JsDocTags: []nativemetadata.IJsDocTagInfo{
+          {Name: "title", Text: []nativemetadata.IJsDocTagInfo_IText{{Text: "Big"}}},
+        },
+      }),
+    },
+  }))
+  if len(constantSchemas) != 1 || constantSchemas[0]["const"] != float64(13) {
+    t.Fatal("JSON schema constant export failed")
+  }
+  dateMeta := nativemetadata.MetadataSchema_initialize()
+  dateMeta.Natives = append(dateMeta.Natives, nativemetadata.MetadataNative_create(nativemetadata.MetadataNative{Name: "Date"}))
+  arrayDate := nativemetadata.MetadataSchema_initialize()
+  arrayDate.Arrays = append(arrayDate.Arrays, nativemetadata.MetadataArray_create(nativemetadata.MetadataArray{
+    Type: nativemetadata.MetadataArrayType_create(nativemetadata.MetadataArrayType{
+      Name:      "Date[]",
+      Value:     dateMeta,
+      Nullables: []bool{},
+    }),
+  }))
+  aliasDate := nativemetadata.MetadataSchema_initialize()
+  aliasDate.Aliases = append(aliasDate.Aliases, nativemetadata.MetadataAlias_create(nativemetadata.MetadataAlias{
+    Type: nativemetadata.MetadataAliasType_create(nativemetadata.MetadataAliasType{Name: "AliasDate", Value: arrayDate}),
+  }))
+  if !json_schema_escaped_is_date(map[*nativemetadata.MetadataSchema]bool{}, aliasDate) ||
+    json_schema_escaped_is_date(map[*nativemetadata.MetadataSchema]bool{aliasDate: true}, aliasDate) {
+    t.Fatal("JSON schema escaped date recursion failed")
+  }
+  if len(json_schema_escaped(struct {
+    components *OpenApi_IComponents
+    escaped    *nativemetadata.MetadataEscaped
+  }{
+    components: &OpenApi_IComponents{},
+    escaped: nativemetadata.MetadataEscaped_create(nativemetadata.MetadataEscaped{
+      Original: dateMeta,
+      Returns:  stringMeta,
+    }),
+  })) == 0 {
+    t.Fatal("JSON schema escaped export returned empty schemas")
+  }
+  taggedTemplate := nativemetadata.MetadataTemplate_create(nativemetadata.MetadataTemplate{
+    Row: []*nativemetadata.MetadataSchema{literal, stringMeta},
+    Tags: [][]nativemetadata.IMetadataTypeTag{{
+      {Name: "MinLength<1>", Kind: "minLength", Schema: map[string]any{"minLength": 1}},
+    }},
+  })
+  templateMeta := nativemetadata.MetadataSchema_initialize()
+  templateMeta.Templates = append(templateMeta.Templates,
+    nativemetadata.MetadataTemplate_create(nativemetadata.MetadataTemplate{Row: []*nativemetadata.MetadataSchema{literal, stringMeta}}),
+    taggedTemplate,
+  )
+  if len(json_schema_templates(templateMeta)) != 2 ||
+    json_schema_template_isPure(taggedTemplate.Tags) {
+    t.Fatal("template schema helper returned unexpected result")
+  }
 
-	components := &OpenApi_IComponents{}
-	if len(Json_schema_native_export(Json_schema_native_export_props{
-		Components: components,
-		Native:     nativemetadata.MetadataNative_create(nativemetadata.MetadataNative{Name: "Blob"}),
-	})) == 0 {
-		t.Fatal("binary native schema export returned empty result")
-	}
-	if len(Json_schema_native_export(Json_schema_native_export_props{
-		Components: components,
-		Native:     nativemetadata.MetadataNative_create(nativemetadata.MetadataNative{Name: "CustomNative"}),
-	})) == 0 || components.Schemas["CustomNative"] == nil {
-		t.Fatal("component native schema export failed")
-	}
-	if !json_schema_station_has_atomic(stringMeta, "string") || lowerAscii("ABC-x") != "abc-x" {
-		t.Fatal("station atomic or lowercase helper mismatch")
-	}
-	anyMeta := nativemetadata.MetadataSchema_create(nativemetadata.MetadataSchema{Any: true, Required: true})
-	if Json_schema_station(Json_schema_station_props{
-		BlockNever: false,
-		Components: components,
-		Attribute:  JsonSchema{"title": "Any"},
-		Metadata:   anyMeta,
-	})["type"] != nil {
-		t.Fatal("any station should synthesize nil type")
-	}
-	if Json_schema_station(Json_schema_station_props{
-		BlockNever: true,
-		Components: components,
-		Metadata:   nativemetadata.MetadataSchema_initialize(),
-	}) != nil {
-		t.Fatal("blockNever station should return nil for empty metadata")
-	}
-	if Json_schema_station(Json_schema_station_props{
-		BlockNever: false,
-		Components: components,
-		Metadata:   nativemetadata.MetadataSchema_initialize(),
-	})["type"] != nil {
-		t.Fatal("empty station should synthesize nil type")
-	}
-	nativeMeta := nativemetadata.MetadataSchema_initialize()
-	nativeMeta.Natives = append(nativeMeta.Natives,
-		nativemetadata.MetadataNative_create(nativemetadata.MetadataNative{Name: "Boolean"}),
-		nativemetadata.MetadataNative_create(nativemetadata.MetadataNative{Name: "BigInt"}),
-		nativemetadata.MetadataNative_create(nativemetadata.MetadataNative{Name: "Number"}),
-		nativemetadata.MetadataNative_create(nativemetadata.MetadataNative{Name: "String"}),
-		nativemetadata.MetadataNative_create(nativemetadata.MetadataNative{Name: "Date"}),
-	)
-	if Json_schema_station(Json_schema_station_props{
-		Components: components,
-		Metadata:   nativeMeta,
-	}) == nil {
-		t.Fatal("native station should produce a schema")
-	}
-	nativeSkipMeta := iterateAtomic("string")
-	nativeSkipMeta.Natives = append(nativeSkipMeta.Natives, nativemetadata.MetadataNative_create(nativemetadata.MetadataNative{Name: "String"}))
-	if Json_schema_station(Json_schema_station_props{
-		Components: components,
-		Metadata:   nativeSkipMeta,
-	}) == nil {
-		t.Fatal("native station should skip duplicated atomic native")
-	}
-	stationObject := nativemetadata.MetadataObjectType_create(nativemetadata.MetadataObjectType{
-		Name: "StationObject",
-		Properties: []*nativemetadata.MetadataProperty{
-			nativemetadata.MetadataProperty_create(nativemetadata.MetadataProperty{Key: literal, Value: stringMeta}),
-		},
-	})
-	stationArray := nativemetadata.MetadataArray_create(nativemetadata.MetadataArray{
-		Type: nativemetadata.MetadataArrayType_create(nativemetadata.MetadataArrayType{Name: "StationArray", Value: stringMeta}),
-	})
-	stationTuple := nativemetadata.MetadataTuple_create(nativemetadata.MetadataTuple{
-		Type: nativemetadata.MetadataTupleType_create(nativemetadata.MetadataTupleType{Name: "StationTuple", Elements: []*nativemetadata.MetadataSchema{stringMeta}}),
-	})
-	stationMeta := nativemetadata.MetadataSchema_initialize()
-	stationMeta.Nullable = true
-	stationMeta.Escaped = nativemetadata.MetadataEscaped_create(nativemetadata.MetadataEscaped{Original: dateMeta, Returns: stringMeta})
-	stationMeta.Templates = append(stationMeta.Templates, taggedTemplate)
-	stationMeta.Constants = append(stationMeta.Constants, nativemetadata.MetadataConstant_create(nativemetadata.MetadataConstant{
-		Type: "boolean",
-		Values: []*nativemetadata.MetadataConstantValue{
-			nativemetadata.MetadataConstantValue_create(nativemetadata.MetadataConstantValue{Value: true}),
-		},
-	}))
-	stationMeta.Atomics = append(stationMeta.Atomics,
-		nativemetadata.MetadataAtomic_create(nativemetadata.MetadataAtomic{Type: "boolean"}),
-		nativemetadata.MetadataAtomic_create(nativemetadata.MetadataAtomic{Type: "bigint"}),
-		nativemetadata.MetadataAtomic_create(nativemetadata.MetadataAtomic{Type: "number"}),
-		nativemetadata.MetadataAtomic_create(nativemetadata.MetadataAtomic{Type: "string"}),
-	)
-	stationMeta.Arrays = append(stationMeta.Arrays, stationArray)
-	stationMeta.Tuples = append(stationMeta.Tuples, stationTuple)
-	stationMeta.Sets = append(stationMeta.Sets, nativemetadata.MetadataSet_create(nativemetadata.MetadataSet{Value: stringMeta}))
-	stationMeta.Maps = append(stationMeta.Maps, nativemetadata.MetadataMap_create(nativemetadata.MetadataMap{Key: stringMeta, Value: stringMeta}))
-	stationMeta.Objects = append(stationMeta.Objects, nativemetadata.MetadataObject_create(nativemetadata.MetadataObject{Type: stationObject}))
-	stationMeta.Aliases = append(stationMeta.Aliases, nativemetadata.MetadataAlias_create(nativemetadata.MetadataAlias{
-		Type: nativemetadata.MetadataAliasType_create(nativemetadata.MetadataAliasType{Name: "StationAlias", Value: stringMeta}),
-	}))
-	if Json_schema_station(Json_schema_station_props{
-		Components: components,
-		Attribute:  JsonSchema{"description": "station"},
-		Metadata:   stationMeta,
-	}) == nil {
-		t.Fatal("union station should produce a schema")
-	}
+  components := &OpenApi_IComponents{}
+  if len(Json_schema_native_export(Json_schema_native_export_props{
+    Components: components,
+    Native:     nativemetadata.MetadataNative_create(nativemetadata.MetadataNative{Name: "Blob"}),
+  })) == 0 {
+    t.Fatal("binary native schema export returned empty result")
+  }
+  if len(Json_schema_native_export(Json_schema_native_export_props{
+    Components: components,
+    Native:     nativemetadata.MetadataNative_create(nativemetadata.MetadataNative{Name: "CustomNative"}),
+  })) == 0 || components.Schemas["CustomNative"] == nil {
+    t.Fatal("component native schema export failed")
+  }
+  if !json_schema_station_has_atomic(stringMeta, "string") || lowerAscii("ABC-x") != "abc-x" {
+    t.Fatal("station atomic or lowercase helper mismatch")
+  }
+  anyMeta := nativemetadata.MetadataSchema_create(nativemetadata.MetadataSchema{Any: true, Required: true})
+  if Json_schema_station(Json_schema_station_props{
+    BlockNever: false,
+    Components: components,
+    Attribute:  JsonSchema{"title": "Any"},
+    Metadata:   anyMeta,
+  })["type"] != nil {
+    t.Fatal("any station should synthesize nil type")
+  }
+  if Json_schema_station(Json_schema_station_props{
+    BlockNever: true,
+    Components: components,
+    Metadata:   nativemetadata.MetadataSchema_initialize(),
+  }) != nil {
+    t.Fatal("blockNever station should return nil for empty metadata")
+  }
+  if Json_schema_station(Json_schema_station_props{
+    BlockNever: false,
+    Components: components,
+    Metadata:   nativemetadata.MetadataSchema_initialize(),
+  })["type"] != nil {
+    t.Fatal("empty station should synthesize nil type")
+  }
+  nativeMeta := nativemetadata.MetadataSchema_initialize()
+  nativeMeta.Natives = append(nativeMeta.Natives,
+    nativemetadata.MetadataNative_create(nativemetadata.MetadataNative{Name: "Boolean"}),
+    nativemetadata.MetadataNative_create(nativemetadata.MetadataNative{Name: "BigInt"}),
+    nativemetadata.MetadataNative_create(nativemetadata.MetadataNative{Name: "Number"}),
+    nativemetadata.MetadataNative_create(nativemetadata.MetadataNative{Name: "String"}),
+    nativemetadata.MetadataNative_create(nativemetadata.MetadataNative{Name: "Date"}),
+  )
+  if Json_schema_station(Json_schema_station_props{
+    Components: components,
+    Metadata:   nativeMeta,
+  }) == nil {
+    t.Fatal("native station should produce a schema")
+  }
+  nativeSkipMeta := iterateAtomic("string")
+  nativeSkipMeta.Natives = append(nativeSkipMeta.Natives, nativemetadata.MetadataNative_create(nativemetadata.MetadataNative{Name: "String"}))
+  if Json_schema_station(Json_schema_station_props{
+    Components: components,
+    Metadata:   nativeSkipMeta,
+  }) == nil {
+    t.Fatal("native station should skip duplicated atomic native")
+  }
+  stationObject := nativemetadata.MetadataObjectType_create(nativemetadata.MetadataObjectType{
+    Name: "StationObject",
+    Properties: []*nativemetadata.MetadataProperty{
+      nativemetadata.MetadataProperty_create(nativemetadata.MetadataProperty{Key: literal, Value: stringMeta}),
+    },
+  })
+  stationArray := nativemetadata.MetadataArray_create(nativemetadata.MetadataArray{
+    Type: nativemetadata.MetadataArrayType_create(nativemetadata.MetadataArrayType{Name: "StationArray", Value: stringMeta}),
+  })
+  stationTuple := nativemetadata.MetadataTuple_create(nativemetadata.MetadataTuple{
+    Type: nativemetadata.MetadataTupleType_create(nativemetadata.MetadataTupleType{Name: "StationTuple", Elements: []*nativemetadata.MetadataSchema{stringMeta}}),
+  })
+  stationMeta := nativemetadata.MetadataSchema_initialize()
+  stationMeta.Nullable = true
+  stationMeta.Escaped = nativemetadata.MetadataEscaped_create(nativemetadata.MetadataEscaped{Original: dateMeta, Returns: stringMeta})
+  stationMeta.Templates = append(stationMeta.Templates, taggedTemplate)
+  stationMeta.Constants = append(stationMeta.Constants, nativemetadata.MetadataConstant_create(nativemetadata.MetadataConstant{
+    Type: "boolean",
+    Values: []*nativemetadata.MetadataConstantValue{
+      nativemetadata.MetadataConstantValue_create(nativemetadata.MetadataConstantValue{Value: true}),
+    },
+  }))
+  stationMeta.Atomics = append(stationMeta.Atomics,
+    nativemetadata.MetadataAtomic_create(nativemetadata.MetadataAtomic{Type: "boolean"}),
+    nativemetadata.MetadataAtomic_create(nativemetadata.MetadataAtomic{Type: "bigint"}),
+    nativemetadata.MetadataAtomic_create(nativemetadata.MetadataAtomic{Type: "number"}),
+    nativemetadata.MetadataAtomic_create(nativemetadata.MetadataAtomic{Type: "string"}),
+  )
+  stationMeta.Arrays = append(stationMeta.Arrays, stationArray)
+  stationMeta.Tuples = append(stationMeta.Tuples, stationTuple)
+  stationMeta.Sets = append(stationMeta.Sets, nativemetadata.MetadataSet_create(nativemetadata.MetadataSet{Value: stringMeta}))
+  stationMeta.Maps = append(stationMeta.Maps, nativemetadata.MetadataMap_create(nativemetadata.MetadataMap{Key: stringMeta, Value: stringMeta}))
+  stationMeta.Objects = append(stationMeta.Objects, nativemetadata.MetadataObject_create(nativemetadata.MetadataObject{Type: stationObject}))
+  stationMeta.Aliases = append(stationMeta.Aliases, nativemetadata.MetadataAlias_create(nativemetadata.MetadataAlias{
+    Type: nativemetadata.MetadataAliasType_create(nativemetadata.MetadataAliasType{Name: "StationAlias", Value: stringMeta}),
+  }))
+  if Json_schema_station(Json_schema_station_props{
+    Components: components,
+    Attribute:  JsonSchema{"description": "station"},
+    Metadata:   stationMeta,
+  }) == nil {
+    t.Fatal("union station should produce a schema")
+  }
 
-	factory := shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
-	input := factory.NewIdentifier("input")
-	value := factory.NewIdentifier("value")
-	optional := iterateAtomic("string")
-	optional.Required = false
-	optional.Optional = true
-	regular := []nativehelpers.IExpressionEntry{
-		{Input: input, Key: literal, Meta: optional, Expression: value},
-		{Input: input, Key: iterateLiteral("second"), Meta: stringMeta, Expression: value},
-	}
-	if len(Stringify_regular_properties(Stringify_regular_propertiesProps{Regular: regular})) == 0 ||
-		stringify_regular_properties_condition(regular[0]) == nil ||
-		stringify_regular_properties_reduce([]*shimast.Node{input, value}, shimast.KindAmpersandAmpersandToken) == nil ||
-		stringify_regular_properties_sequence(optional) != 0 {
-		t.Fatal("regular stringify property helper failed")
-	}
-	dynamicString := nativehelpers.IExpressionEntry{Input: input, Key: stringMeta, Meta: stringMeta, Expression: value}
-	dynamicPattern := nativehelpers.IExpressionEntry{Input: input, Key: literal, Meta: stringMeta, Expression: value}
-	if Stringify_dynamic_properties([]nativehelpers.IExpressionEntry{dynamicString}, []string{"fixed"}) == nil ||
-		Stringify_dynamic_properties([]nativehelpers.IExpressionEntry{dynamicPattern}, nil) == nil ||
-		stringify_dynamic_properties_stringify(dynamicString) == nil ||
-		stringify_dynamic_properties_binding_pattern() == nil {
-		t.Fatal("dynamic stringify property helper failed")
-	}
-
-	object := nativemetadata.MetadataObjectType_create(nativemetadata.MetadataObjectType{
-		Name: "IterateObject",
-		Properties: []*nativemetadata.MetadataProperty{
-			nativemetadata.MetadataProperty_create(nativemetadata.MetadataProperty{Key: literal, Value: stringMeta}),
-			nativemetadata.MetadataProperty_create(nativemetadata.MetadataProperty{Key: stringMeta, Value: stringMeta}),
-		},
-	})
-	if Prune_object_properties(object) == nil ||
-		prune_object_properties_reduce([]*shimast.Node{input, value}, shimast.KindBarBarToken) == nil ||
-		Stringify_native() == nil {
-		t.Fatal("prune or native stringify helper failed")
-	}
 }
 
 func iterateLiteral(value string) *nativemetadata.MetadataSchema {
-	meta := nativemetadata.MetadataSchema_initialize()
-	meta.Constants = append(meta.Constants, nativemetadata.MetadataConstant_create(nativemetadata.MetadataConstant{
-		Type: "string",
-		Values: []*nativemetadata.MetadataConstantValue{
-			nativemetadata.MetadataConstantValue_create(nativemetadata.MetadataConstantValue{Value: value}),
-		},
-	}))
-	return meta
+  meta := nativemetadata.MetadataSchema_initialize()
+  meta.Constants = append(meta.Constants, nativemetadata.MetadataConstant_create(nativemetadata.MetadataConstant{
+    Type: "string",
+    Values: []*nativemetadata.MetadataConstantValue{
+      nativemetadata.MetadataConstantValue_create(nativemetadata.MetadataConstantValue{Value: value}),
+    },
+  }))
+  return meta
 }
 
 func iterateAtomic(kind string) *nativemetadata.MetadataSchema {
-	meta := nativemetadata.MetadataSchema_initialize()
-	meta.Atomics = append(meta.Atomics, nativemetadata.MetadataAtomic_create(nativemetadata.MetadataAtomic{Type: kind}))
-	return meta
+  meta := nativemetadata.MetadataSchema_initialize()
+  meta.Atomics = append(meta.Atomics, nativemetadata.MetadataAtomic_create(nativemetadata.MetadataAtomic{Type: kind}))
+  return meta
 }

package/native/core/programmers/iterate/json_schema_object.go

@@ -55,10 +55,16 @@ func json_schema_create_object_schema(props struct {
   required := []string{}
 
   for _, property := range props.object.Type.Properties {
-    if len(property.Value.Functions) != 0 &&
-      property.Value.Nullable == false &&
-      property.Value.IsRequired() &&
-      property.Value.Size() == 0 {
+    // A member that is only a function has no JSON to describe, so the schema
+    // drops it exactly as the serializer does. The condition has to match the
+    // serializer's (`StringifyJoiner`) or the two disagree about the same type:
+    // `Size()` counts `Functions`, so a pure function member is size 1 and a
+    // `Size() == 0` test could never fire for the case it was written to catch,
+    // leaving the member described as a `$ref` to an empty component — a schema
+    // for a document `json.stringify` never produces. Optionality is not part of
+    // the question either; an optional function member has no JSON either
+    // (samchon/typia#2270).
+    if json_schema_object_function_only(property.Value) {
       continue
     }
     if json_schema_has_any_tag(property.JsDocTags, []string{"hidden", "ignore", "internal"}) {
@@ -111,7 +117,7 @@ func json_schema_create_object_schema(props struct {
       if pattern == nativeutils.PatternUtil.STRING {
         extraMeta.additionalProperties = &pair
       } else {
-        extraMeta.patternProperties[pattern] = pair
+        extraMeta.setPatternProperty(pattern, pair)
       }
     }
   }
@@ -152,8 +158,8 @@ func json_schema_join(props struct {
   extra      json_schema_superfluous
 }) JsonSchema {
   elements := []json_schema_metadata_schema_pair{}
-  for _, value := range props.extra.patternProperties {
-    elements = append(elements, value)
+  for _, key := range props.extra.patternPropertyKeys {
+    elements = append(elements, props.extra.patternProperties[key])
   }
   if props.extra.additionalProperties != nil {
     elements = append(elements, *props.extra.additionalProperties)
@@ -179,9 +185,45 @@ func json_schema_join(props struct {
 type json_schema_superfluous struct {
   additionalProperties *json_schema_metadata_schema_pair
   patternProperties    map[string]json_schema_metadata_schema_pair
+  // patternPropertyKeys preserves the first-insertion order of the map while
+  // later assignments to an existing pattern replace its value in place.
+  patternPropertyKeys []string
+}
+
+func (superfluous *json_schema_superfluous) setPatternProperty(pattern string, pair json_schema_metadata_schema_pair) {
+  if _, exists := superfluous.patternProperties[pattern]; exists == false {
+    superfluous.patternPropertyKeys = append(superfluous.patternPropertyKeys, pattern)
+  }
+  superfluous.patternProperties[pattern] = pair
 }
 
 type json_schema_metadata_schema_pair struct {
   metadata *nativemetadata.MetadataSchema
   schema   JsonSchema
 }
+
+// json_schema_object_function_only reports whether a member has no JSON to
+// describe because it is only a function, so the schema drops it exactly as the
+// serializer does.
+//
+// The condition has to agree with the serializer's (`StringifyJoiner`) or the
+// two describe the same type differently. Two ways it disagreed: `Size()` counts
+// `Functions`, so a pure function member is size 1 and the previous
+// `Size() == 0` test could never fire for the case it was written to catch; and
+// a named alias of a function type carries `Aliases`, not `Functions`, so the
+// same type reached through `type Consumer = (v: number) => string` survived as
+// a `$ref` to an empty component while the interface spelling of it vanished —
+// two documents for one type, and neither `json.stringify` ever produces
+// (samchon/typia#2270).
+//
+// Optionality is deliberately not part of the question: an optional function
+// member has no JSON either.
+func json_schema_object_function_only(value *nativemetadata.MetadataSchema) bool {
+  if value == nil {
+    return false
+  }
+  resolved := nativemetadata.MetadataSchema_unalias(value)
+  return len(resolved.Functions) != 0 &&
+    resolved.Nullable == false &&
+    resolved.Size() == 1
+}