typia 13.0.0-dev.20260511 → 13.0.0-dev.20260514

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

@@ -1,56 +1,63 @@
 package metadata
 
 import (
-  nativechecker "github.com/microsoft/typescript-go/shim/checker"
-  schemametadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+	nativechecker "github.com/microsoft/typescript-go/shim/checker"
+	schemametadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
 )
 
 type MetadataFactory_IOptions struct {
-  Escape     bool
-  Absorb     bool
-  Constant   bool
-  Functional bool
-  Validate   func(props struct {
-    Metadata *schemametadata.MetadataSchema
-    Explore  MetadataFactory_IExplore
-    Top      *schemametadata.MetadataSchema
-  }) []string
-  OnError func(node any, message string)
+	Escape     bool
+	Absorb     bool
+	Constant   bool
+	Functional bool
+	Validate   func(props struct {
+		Metadata *schemametadata.MetadataSchema
+		Explore  MetadataFactory_IExplore
+		Top      *schemametadata.MetadataSchema
+	}) []string
+	OnError func(node any, message string)
 }
 
 type MetadataFactory_IError struct {
-  Name     string
-  Explore  MetadataFactory_IExplore
-  Messages []string
+	Name     string
+	Explore  MetadataFactory_IExplore
+	Messages []string
 }
 
 type MetadataFactory_IExplore struct {
-  Top       bool
-  Object    *schemametadata.MetadataObjectType
-  Property  any
-  Parameter any
-  Nested    any
-  Aliased   bool
-  Escaped   bool
-  Output    bool
+	Top       bool
+	Object    *schemametadata.MetadataObjectType
+	Property  any
+	Parameter any
+	Nested    any
+	Aliased   bool
+	Escaped   bool
+	Output    bool
 }
 
 type MetadataFactory_IExplore_Function func(MetadataFactory_IExplore) MetadataFactory_IExplore
 
 type IMetadataIteratorProps struct {
-  Options     MetadataFactory_IOptions
-  Checker     *nativechecker.Checker
-  Components  *schemametadata.MetadataCollection
-  Errors      *[]MetadataFactory_IError
-  Metadata    *schemametadata.MetadataSchema
-  Type        *nativechecker.Type
-  Explore     MetadataFactory_IExplore
-  Intersected bool
+	Options     MetadataFactory_IOptions
+	Checker     *nativechecker.Checker
+	Components  *schemametadata.MetadataCollection
+	Errors      *[]MetadataFactory_IError
+	Metadata    *schemametadata.MetadataSchema
+	Type        *nativechecker.Type
+	Explore     MetadataFactory_IExplore
+	Intersected bool
 }
 
 var MetadataTypeTagAnalyzer func(props struct {
-  Errors  *[]MetadataFactory_IError
-  Type    string
-  Objects []*schemametadata.MetadataObjectType
-  Explore MetadataFactory_IExplore
+	Errors  *[]MetadataFactory_IError
+	Type    string
+	Objects []*schemametadata.MetadataObjectType
+	Explore MetadataFactory_IExplore
 }) []schemametadata.IMetadataTypeTag
+
+var MetadataCommentTagAnalyzer func(props struct {
+	Errors   *[]MetadataFactory_IError
+	Metadata *schemametadata.MetadataSchema
+	Tags     []schemametadata.IJsDocTagInfo
+	Explore  MetadataFactory_IExplore
+})

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

@@ -1,11 +1,12 @@
 package metadata
 
 import (
-  "strings"
+	"strings"
 
-  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"
+	nativeast "github.com/microsoft/typescript-go/shim/ast"
+	nativechecker "github.com/microsoft/typescript-go/shim/checker"
+	nativescanner "github.com/microsoft/typescript-go/shim/scanner"
+	schemametadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
 )
 
 type metadataHelperNamespace struct{}
@@ -13,213 +14,245 @@ type metadataHelperNamespace struct{}
 var MetadataHelper = metadataHelperNamespace{}
 
 func (metadataHelperNamespace) Literal_to_metadata(key string) *schemametadata.MetadataSchema {
-  metadata := schemametadata.MetadataSchema_initialize()
-  metadata.Constants = append(metadata.Constants, schemametadata.MetadataConstant_create(schemametadata.MetadataConstant{
-    Type: "string",
-    Values: []*schemametadata.MetadataConstantValue{
-      schemametadata.MetadataConstantValue_create(schemametadata.MetadataConstantValue{
-        Value: key,
-        Tags:  [][]schemametadata.IMetadataTypeTag{},
-      }),
-    },
-  }))
-  return metadata
+	metadata := schemametadata.MetadataSchema_initialize()
+	metadata.Constants = append(metadata.Constants, schemametadata.MetadataConstant_create(schemametadata.MetadataConstant{
+		Type: "string",
+		Values: []*schemametadata.MetadataConstantValue{
+			schemametadata.MetadataConstantValue_create(schemametadata.MetadataConstantValue{
+				Value: key,
+				Tags:  [][]schemametadata.IMetadataTypeTag{},
+			}),
+		},
+	}))
+	return metadata
 }
 
 func metadata_array_util_add_bool(array *[]bool, value bool) {
-  for _, elem := range *array {
-    if elem == value {
-      return
-    }
-  }
-  *array = append(*array, value)
+	for _, elem := range *array {
+		if elem == value {
+			return
+		}
+	}
+	*array = append(*array, value)
 }
 
 func metadata_type_full_name(checker *nativechecker.Checker, typ *nativechecker.Type) string {
-  if checker == nil || typ == nil {
-    return ""
-  }
-  if typ.IsUnion() || typ.IsIntersection() {
-    joiner := " | "
-    if typ.IsIntersection() {
-      joiner = " & "
-    }
-    children := typ.Types()
-    names := make([]string, 0, len(children))
-    for _, child := range children {
-      names = append(names, metadata_type_full_name(checker, child))
-    }
-    return strings.Join(names, joiner)
-  }
-  return checker.TypeToString(typ)
+	if checker == nil || typ == nil {
+		return ""
+	}
+	if typ.IsUnion() || typ.IsIntersection() {
+		joiner := " | "
+		if typ.IsIntersection() {
+			joiner = " & "
+		}
+		children := typ.Types()
+		names := make([]string, 0, len(children))
+		for _, child := range children {
+			names = append(names, metadata_type_full_name(checker, child))
+		}
+		return strings.Join(names, joiner)
+	}
+	return checker.TypeToString(typ)
 }
 
 func metadata_get_type_arguments(checker *nativechecker.Checker, typ *nativechecker.Type) (output []*nativechecker.Type) {
-  if checker == nil || typ == nil {
-    return nil
-  }
-  defer func() {
-    if recover() != nil {
-      output = nil
-    }
-  }()
-  return checker.GetTypeArguments(typ)
+	if checker == nil || typ == nil {
+		return nil
+	}
+	defer func() {
+		if recover() != nil {
+			output = nil
+		}
+	}()
+	return checker.GetTypeArguments(typ)
 }
 
 func metadata_get_function_node(typ *nativechecker.Type) *nativeast.Node {
-  if typ == nil {
-    return nil
-  }
-  symbol := typ.Symbol()
-  if symbol == nil || len(symbol.Declarations) == 0 {
-    return nil
-  }
-  node := symbol.Declarations[0]
-  if nativeast.IsFunctionLike(node) {
-    return node
-  }
-  if nativeast.IsPropertyAssignment(node) {
-    initializer := node.AsPropertyAssignment().Initializer
-    if nativeast.IsFunctionLike(initializer) {
-      return initializer
-    }
-    return nil
-  }
-  if nativeast.IsPropertyDeclaration(node) {
-    initializer := node.AsPropertyDeclaration().Initializer
-    if nativeast.IsFunctionLike(initializer) {
-      return initializer
-    }
-  }
-  return nil
+	if typ == nil {
+		return nil
+	}
+	symbol := typ.Symbol()
+	if symbol == nil || len(symbol.Declarations) == 0 {
+		return nil
+	}
+	node := symbol.Declarations[0]
+	if nativeast.IsFunctionLike(node) {
+		return node
+	}
+	if nativeast.IsPropertyAssignment(node) {
+		initializer := node.AsPropertyAssignment().Initializer
+		if nativeast.IsFunctionLike(initializer) {
+			return initializer
+		}
+		return nil
+	}
+	if nativeast.IsPropertyDeclaration(node) {
+		initializer := node.AsPropertyDeclaration().Initializer
+		if nativeast.IsFunctionLike(initializer) {
+			return initializer
+		}
+	}
+	return nil
 }
 
 func metadata_get_return_type_of_class_method(props struct {
-  Checker  *nativechecker.Checker
-  Class    *nativechecker.Type
-  Function string
+	Checker  *nativechecker.Checker
+	Class    *nativechecker.Type
+	Function string
 }) *nativechecker.Type {
-  if props.Checker == nil || props.Class == nil {
-    return nil
-  }
-  symbol := props.Checker.GetPropertyOfType(props.Class, props.Function)
-  if symbol == nil || symbol.ValueDeclaration == nil {
-    return nil
-  }
-  functor := props.Checker.GetTypeOfSymbolAtLocation(symbol, symbol.ValueDeclaration)
-  signatures := props.Checker.GetSignaturesOfType(functor, nativechecker.SignatureKindCall)
-  if len(signatures) == 0 {
-    return nil
-  }
-  return props.Checker.GetReturnTypeOfSignature(signatures[0])
+	if props.Checker == nil || props.Class == nil {
+		return nil
+	}
+	symbol := props.Checker.GetPropertyOfType(props.Class, props.Function)
+	if symbol == nil || symbol.ValueDeclaration == nil {
+		return nil
+	}
+	functor := props.Checker.GetTypeOfSymbolAtLocation(symbol, symbol.ValueDeclaration)
+	signatures := props.Checker.GetSignaturesOfType(functor, nativechecker.SignatureKindCall)
+	if len(signatures) == 0 {
+		return nil
+	}
+	return props.Checker.GetReturnTypeOfSignature(signatures[0])
 }
 
 func metadata_node_js_doc_tags(symbol *nativeast.Symbol) []schemametadata.IJsDocTagInfo {
-  output := []schemametadata.IJsDocTagInfo{}
-  for _, node := range metadata_node_declarations(symbol) {
-    for _, jsdoc := range node.JSDoc(nil) {
-      doc := jsdoc.AsJSDoc()
-      if doc == nil || doc.Tags == nil {
-        continue
-      }
-      for _, tag := range doc.Tags.Nodes {
-        if tag == nil || tag.TagName() == nil {
-          continue
-        }
-        texts := []schemametadata.IJsDocTagInfo_IText{}
-        if name := metadata_js_doc_parameter_name(tag); name != "" {
-          texts = append(texts, schemametadata.IJsDocTagInfo_IText{
-            Kind: "parameterName",
-            Text: name,
-          })
-        }
-        if text := metadata_js_doc_comment_text(tag.CommentList()); text != "" {
-          texts = append(texts, schemametadata.IJsDocTagInfo_IText{
-            Kind: "text",
-            Text: text,
-          })
-        }
-        output = append(output, schemametadata.IJsDocTagInfo{
-          Name: tag.TagName().Text(),
-          Text: texts,
-        })
-      }
-    }
-  }
-  return output
+	output := []schemametadata.IJsDocTagInfo{}
+	for _, node := range metadata_node_declarations(symbol) {
+		for _, jsdoc := range node.JSDoc(nil) {
+			doc := jsdoc.AsJSDoc()
+			if doc == nil || doc.Tags == nil {
+				continue
+			}
+			for _, tag := range doc.Tags.Nodes {
+				if tag == nil || tag.TagName() == nil {
+					continue
+				}
+				texts := []schemametadata.IJsDocTagInfo_IText{}
+				if name := metadata_js_doc_parameter_name(tag); name != "" {
+					texts = append(texts, schemametadata.IJsDocTagInfo_IText{
+						Kind: "parameterName",
+						Text: name,
+					})
+				}
+				if text := metadata_js_doc_type_expression_text(tag); text != "" {
+					texts = append(texts, schemametadata.IJsDocTagInfo_IText{
+						Kind: "text",
+						Text: text,
+					})
+				}
+				if text := metadata_js_doc_comment_text(tag.CommentList()); text != "" {
+					texts = append(texts, schemametadata.IJsDocTagInfo_IText{
+						Kind: "text",
+						Text: text,
+					})
+				}
+				output = append(output, schemametadata.IJsDocTagInfo{
+					Name: tag.TagName().Text(),
+					Text: texts,
+				})
+			}
+		}
+	}
+	return output
 }
 
 func metadata_node_description(symbol *nativeast.Symbol) *string {
-  for _, node := range metadata_node_declarations(symbol) {
-    for _, jsdoc := range node.JSDoc(nil) {
-      doc := jsdoc.AsJSDoc()
-      if doc == nil {
-        continue
-      }
-      if text := metadata_js_doc_comment_text(doc.Comment); text != "" {
-        return &text
-      }
-    }
-  }
-  return nil
+	for _, node := range metadata_node_declarations(symbol) {
+		for _, jsdoc := range node.JSDoc(nil) {
+			doc := jsdoc.AsJSDoc()
+			if doc == nil {
+				continue
+			}
+			if text := metadata_js_doc_comment_text(doc.Comment); text != "" {
+				return &text
+			}
+		}
+	}
+	return nil
 }
 
 func metadata_is_internal(symbol *nativeast.Symbol) bool {
-  return false
+	return false
 }
 
 func metadata_node_declarations(symbol *nativeast.Symbol) []*nativeast.Node {
-  if symbol == nil {
-    return nil
-  }
-  output := []*nativeast.Node{}
-  visited := map[*nativeast.Node]bool{}
-  appendNode := func(node *nativeast.Node) {
-    if node != nil && visited[node] == false {
-      visited[node] = true
-      output = append(output, node)
-    }
-  }
-  appendNode(symbol.ValueDeclaration)
-  for _, node := range symbol.Declarations {
-    appendNode(node)
-  }
-  return output
+	if symbol == nil {
+		return nil
+	}
+	output := []*nativeast.Node{}
+	visited := map[*nativeast.Node]bool{}
+	appendNode := func(node *nativeast.Node) {
+		if node != nil && visited[node] == false {
+			visited[node] = true
+			output = append(output, node)
+		}
+	}
+	appendNode(symbol.ValueDeclaration)
+	for _, node := range symbol.Declarations {
+		appendNode(node)
+	}
+	return output
 }
 
 func metadata_js_doc_parameter_name(tag *nativeast.Node) string {
-  if tag == nil {
-    return ""
-  }
-  if tag.Kind.String() != "KindJSDocParameterTag" && tag.Kind.String() != "KindJSDocPropertyTag" {
-    return ""
-  }
-  name := tag.AsJSDocParameterOrPropertyTag().Name()
-  if name == nil {
-    return ""
-  }
-  return name.Text()
+	if tag == nil {
+		return ""
+	}
+	if tag.Kind.String() != "KindJSDocParameterTag" && tag.Kind.String() != "KindJSDocPropertyTag" {
+		return ""
+	}
+	name := tag.AsJSDocParameterOrPropertyTag().Name()
+	if name == nil {
+		return ""
+	}
+	return name.Text()
+}
+
+func metadata_js_doc_type_expression_text(tag *nativeast.Node) string {
+	if tag == nil {
+		return ""
+	}
+	switch tag.Kind {
+	case nativeast.KindJSDocTypeTag,
+		nativeast.KindJSDocParameterTag,
+		nativeast.KindJSDocPropertyTag,
+		nativeast.KindJSDocReturnTag,
+		nativeast.KindJSDocTypedefTag,
+		nativeast.KindJSDocSatisfiesTag,
+		nativeast.KindJSDocThrowsTag:
+	default:
+		return ""
+	}
+	expr := tag.TypeExpression()
+	if expr == nil {
+		return ""
+	}
+	typ := expr.Type()
+	if typ == nil {
+		return ""
+	}
+	return metadata_clean_js_doc_text(nativescanner.GetTextOfNode(typ))
 }
 
 func metadata_js_doc_comment_text(list *nativeast.NodeList) string {
-  if list == nil {
-    return ""
-  }
-  parts := []string{}
-  for _, node := range list.Nodes {
-    if node != nil {
-      parts = append(parts, node.Text())
-    }
-  }
-  return metadata_clean_js_doc_text(strings.Join(parts, ""))
+	if list == nil {
+		return ""
+	}
+	parts := []string{}
+	for _, node := range list.Nodes {
+		if node != nil {
+			parts = append(parts, node.Text())
+		}
+	}
+	return metadata_clean_js_doc_text(strings.Join(parts, ""))
 }
 
 func metadata_clean_js_doc_text(text string) string {
-  text = strings.ReplaceAll(text, "\r\n", "\n")
-  text = strings.ReplaceAll(text, "\r", "\n")
-  lines := strings.Split(text, "\n")
-  for i, line := range lines {
-    lines[i] = strings.TrimRight(line, " \t")
-  }
-  return strings.TrimSpace(strings.Join(lines, "\n"))
+	text = strings.ReplaceAll(text, "\r\n", "\n")
+	text = strings.ReplaceAll(text, "\r", "\n")
+	lines := strings.Split(text, "\n")
+	for i, line := range lines {
+		lines[i] = strings.TrimRight(line, " \t")
+	}
+	return strings.TrimSpace(strings.Join(lines, "\n"))
 }

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

@@ -3,18 +3,32 @@ package metadata
 import schemametadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
 
 func Iterate_metadata_comment_tags(props struct {
-  Errors *[]MetadataFactory_IError
-  Object *schemametadata.MetadataObjectType
+	Errors *[]MetadataFactory_IError
+	Object *schemametadata.MetadataObjectType
 }) {
-  if props.Object == nil || props.Object.Tagged_ == true {
-    return
-  }
-  props.Object.Tagged_ = true
+	if props.Object == nil || props.Object.Tagged_ == true || MetadataCommentTagAnalyzer == nil {
+		return
+	}
+	props.Object.Tagged_ = true
 
-  for _, property := range props.Object.Properties {
-    _ = property
-    // JSDoc extraction through the TypeScript-Go shim is not yet complete.
-    // The traversal point is kept in the original file location so the
-    // MetadataCommentTagFactory port can be wired without changing callers.
-  }
+	for _, property := range props.Object.Properties {
+		if property == nil || property.Value == nil || len(property.JsDocTags) == 0 {
+			continue
+		}
+		MetadataCommentTagAnalyzer(struct {
+			Errors   *[]MetadataFactory_IError
+			Metadata *schemametadata.MetadataSchema
+			Tags     []schemametadata.IJsDocTagInfo
+			Explore  MetadataFactory_IExplore
+		}{
+			Errors:   props.Errors,
+			Metadata: property.Value,
+			Tags:     property.JsDocTags,
+			Explore: MetadataFactory_IExplore{
+				Top:      false,
+				Object:   props.Object,
+				Property: property,
+			},
+		})
+	}
 }

package/native/go.work

@@ -0,0 +1,22 @@
+go 1.26
+
+use (
+	.
+	../../../../ttsc/packages/ttsc
+	../../../../ttsc/packages/ttsc/shim/ast
+	../../../../ttsc/packages/ttsc/shim/bundled
+	../../../../ttsc/packages/ttsc/shim/checker
+	../../../../ttsc/packages/ttsc/shim/compiler
+	../../../../ttsc/packages/ttsc/shim/core
+	../../../../ttsc/packages/ttsc/shim/diagnosticwriter
+	../../../../ttsc/packages/ttsc/shim/parser
+	../../../../ttsc/packages/ttsc/shim/printer
+	../../../../ttsc/packages/ttsc/shim/scanner
+	../../../../ttsc/packages/ttsc/shim/tsoptions
+	../../../../ttsc/packages/ttsc/shim/tspath
+	../../../../ttsc/packages/ttsc/shim/vfs
+	../../../../ttsc/packages/ttsc/shim/vfs/cachedvfs
+	../../../../ttsc/packages/ttsc/shim/vfs/osvfs
+)
+
+replace github.com/samchon/ttsc/packages/ttsc v0.0.0 => ../../../../ttsc/packages/ttsc

package/native/transform/CallExpressionTransformer.go

@@ -29,10 +29,19 @@ type CallExpressionTransformer_TransformProps struct {
   Expression *shimast.CallExpression
 }
 
+type CallExpressionTransformer_TransformKnownProps struct {
+  Context    nativecontext.ITypiaContext
+  Expression *shimast.CallExpression
+  Module     string
+  Method     string
+}
+
 type callExpressionTransformerTask func(props ITransformProps) *shimast.Node
 
 type callExpressionTransformerFunctor func() callExpressionTransformerTask
 
+var callExpressionTransformer_functors = callExpressionTransformer_createFunctors()
+
 func (callExpressionTransformerNamespace) Transform(props CallExpressionTransformer_TransformProps) *shimast.Node {
   if props.Expression == nil {
     return nil
@@ -59,8 +68,20 @@ func (callExpressionTransformerNamespace) Transform(props CallExpressionTransfor
     return props.Expression.AsNode()
   }
   name := typ.Symbol().Name
+  return CallExpressionTransformer.TransformKnown(CallExpressionTransformer_TransformKnownProps{
+    Context:    props.Context,
+    Expression: props.Expression,
+    Module:     module,
+    Method:     name,
+  })
+}
+
+func (callExpressionTransformerNamespace) TransformKnown(props CallExpressionTransformer_TransformKnownProps) *shimast.Node {
+  if props.Expression == nil {
+    return nil
+  }
   functors := callExpressionTransformer_FUNCTORS()
-  functor, ok := functors[module][name]
+  functor, ok := functors[props.Module][props.Method]
   if ok == false {
     return props.Expression.AsNode()
   }
@@ -101,6 +122,10 @@ func callExpressionTransformer_sourceFile(node *shimast.Node) *shimast.SourceFil
 }
 
 func callExpressionTransformer_FUNCTORS() map[string]map[string]callExpressionTransformerFunctor {
+  return callExpressionTransformer_functors
+}
+
+func callExpressionTransformer_createFunctors() map[string]map[string]callExpressionTransformerFunctor {
   return map[string]map[string]callExpressionTransformerFunctor{
     "module": {
       "assert": func() callExpressionTransformerTask {