typia 13.0.1-dev.20260703.1 → 13.0.2

package/native/transform/FileTransformer.go

@@ -1,221 +1,221 @@
-package transform
-
-import (
-  "sync"
-
-  shimast "github.com/microsoft/typescript-go/shim/ast"
-  shimchecker "github.com/microsoft/typescript-go/shim/checker"
-  shimcore "github.com/microsoft/typescript-go/shim/core"
-  shimprinter "github.com/microsoft/typescript-go/shim/printer"
-  "github.com/samchon/ttsc/packages/ttsc/driver"
-  nativecontext "github.com/samchon/typia/packages/typia/native/core/context"
-)
-
-type fileTransformerNamespace struct{}
-
-var FileTransformer = fileTransformerNamespace{}
-
-type FileTransformer_IEnvironments struct {
-  Program         any
-  CompilerOptions any
-  Checker         any
-  Options         nativecontext.ITransformOptions
-  Extras          nativecontext.ITypiaContext_Extras
-  // EmitContext, when set, puts the importer into AST-integration mode so the
-  // emitted file carries namespace imports that tsgo's module-transform aliases,
-  // instead of bare identifiers meant for the legacy text-splice path.
-  EmitContext *shimprinter.EmitContext
-}
-
-type FileTransformer_Type func(file *shimast.SourceFile) *shimast.SourceFile
-
-var fileTransformer_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
-var fileTransformer_jsDocParsingMode sync.Map
-
-func (fileTransformerNamespace) Transform(environments FileTransformer_IEnvironments) func(transformer any) FileTransformer_Type {
-  return func(transformer any) FileTransformer_Type {
-    return func(file *shimast.SourceFile) *shimast.SourceFile {
-      if file == nil || file.IsDeclarationFile {
-        return file
-      }
-      importer := nativecontext.NewImportProgrammer(nativecontext.ImportProgrammer_IOptions{
-        InternalPrefix: "typia_transform_",
-        Runtime:        environments.Options.Runtime,
-      })
-      if environments.EmitContext != nil {
-        importer.SetEmitContext(environments.EmitContext)
-      }
-      context := nativecontext.ITypiaContext{
-        Program:         fileTransformer_program(environments.Program),
-        CompilerOptions: fileTransformer_compilerOptions(environments.CompilerOptions),
-        Checker:         fileTransformer_checker(environments.Checker),
-        Options:         environments.Options,
-        Emit:            environments.EmitContext,
-        Importer:        importer,
-        Extras:          environments.Extras,
-      }
-      _ = transformer
-      fileTransformer_checkJsDocParsingMode(context, file)
-      visited := fileTransformer_iterate_file(context, file)
-      result := fileTransformer_inject_imports(visited, importer.ToStatements(), environments.EmitContext)
-      return result
-    }
-  }
-}
-
-func fileTransformer_iterate_file(context nativecontext.ITypiaContext, file *shimast.SourceFile) *shimast.SourceFile {
-  var visitor *shimast.NodeVisitor
-  visit := func(node *shimast.Node) *shimast.Node {
-    if node == nil {
-      return nil
-    }
-    next := fileTransformer_try_transform_node(FileTransformer_TryTransformNodeProps{
-      Context: context,
-      File:    file,
-      Node:    node,
-    })
-    if next == nil {
-      next = node
-    }
-    return visitor.VisitEachChild(next)
-  }
-  // Traverse with the emit context when available. Recreated ancestor nodes then
-  // retain original parse-tree links, which lets tsgo's emit resolver recover
-  // binder symbols and lower exported namespaces correctly. The standalone
-  // factory loses those links, so module exports can disappear silently.
-  if context.Emit != nil {
-    visitor = context.Emit.NewNodeVisitor(visit)
-  } else {
-    visitor = shimast.NewNodeVisitor(visit, fileTransformer_factory, shimast.NodeVisitorHooks{})
-  }
-  output := visitor.VisitNode(file.AsNode())
-  if output == nil {
-    return file
-  }
-  return output.AsSourceFile()
-}
-
-type FileTransformer_TryTransformNodeProps struct {
-  Context nativecontext.ITypiaContext
-  File    *shimast.SourceFile
-  Node    *shimast.Node
-}
-
-func fileTransformer_try_transform_node(props FileTransformer_TryTransformNodeProps) (output *shimast.Node) {
-  defer func() {
-    if exp := recover(); exp != nil {
-      // typia raises a TransformerError to report a user-facing transform error
-      // (e.g. `typia.llm.schema<Record<...>>` whose argument is not a literal
-      // object). core/programmers panic nativecontext.TransformerError while
-      // transform/features panic the transform-layer alias; both must turn into
-      // a diagnostic, not a repanic that kills the whole emit (the legacy text
-      // adapter swallowed every panic, so the node path must at least handle
-      // both error types).
-      switch err := exp.(type) {
-      case *TransformerError:
-        fileTransformer_addDiagnostic(props, err.Code, err.Message)
-        output = nil
-        return
-      case *nativecontext.TransformerError:
-        fileTransformer_addDiagnostic(props, err.Code, err.Message)
-        output = nil
-        return
-      }
-      panic(exp)
-    }
-  }()
-  return NodeTransformer.Transform(NodeTransformer_TransformProps{
-    Context: props.Context,
-    Node:    props.Node,
-  })
-}
-
-func fileTransformer_addDiagnostic(props FileTransformer_TryTransformNodeProps, code string, message string) {
-  if props.Context.Extras.AddDiagnostic == nil {
-    return
-  }
-  text := "typia transform error"
-  if message != "" {
-    text += ": " + message
-  }
-  diag := &nativecontext.ITypiaDiagnostic{
-    File:    props.File,
-    Code:    code,
-    Message: text,
-  }
-  if props.Node != nil {
-    if pos := props.Node.Pos(); pos >= 0 {
-      diag.Start = &pos
-      if end := props.Node.End(); end >= pos {
-        length := end - pos
-        diag.Length = &length
-      }
-    }
-  }
-  props.Context.Extras.AddDiagnostic(diag)
-}
-
-func fileTransformer_inject_imports(file *shimast.SourceFile, imports []*shimast.Node, emit ...*shimprinter.EmitContext) *shimast.SourceFile {
-  if file == nil || len(imports) == 0 {
-    return file
-  }
-  f := nativecontext.EmitFactoryOf(fileTransformer_factory, emit...)
-  index := fileTransformer_find_import_injection_index(file)
-  nodes := make([]*shimast.Node, 0, len(file.Statements.Nodes)+len(imports))
-  nodes = append(nodes, file.Statements.Nodes[:index]...)
-  nodes = append(nodes, imports...)
-  nodes = append(nodes, file.Statements.Nodes[index:]...)
-  return f.UpdateSourceFile(
-    file,
-    f.NewNodeList(nodes),
-    file.EndOfFileToken,
-  ).AsSourceFile()
-}
-
-func fileTransformer_find_import_injection_index(file *shimast.SourceFile) int {
-  i := 0
-  for ; i < len(file.Statements.Nodes); i++ {
-    stmt := file.Statements.Nodes[i]
-    if stmt == nil || stmt.Kind != shimast.KindExpressionStatement {
-      break
-    }
-    expression := stmt.AsExpressionStatement().Expression
-    if expression == nil || expression.Kind != shimast.KindStringLiteral {
-      break
-    }
-    if text := expression.AsStringLiteral().Text; len(text) < 4 || text[:4] != "use " {
-      break
-    }
-  }
-  return i
-}
-
-func fileTransformer_checkJsDocParsingMode(context nativecontext.ITypiaContext, file *shimast.SourceFile) {
-  if file == nil || context.Extras.AddDiagnostic == nil {
-    return
-  }
-  if _, loaded := fileTransformer_jsDocParsingMode.LoadOrStore(file.FileName(), struct{}{}); loaded {
-    return
-  }
-}
-
-func fileTransformer_program(value any) *driver.Program {
-  if cast, ok := value.(*driver.Program); ok {
-    return cast
-  }
-  return nil
-}
-
-func fileTransformer_compilerOptions(value any) *shimcore.CompilerOptions {
-  if cast, ok := value.(*shimcore.CompilerOptions); ok {
-    return cast
-  }
-  return nil
-}
-
-func fileTransformer_checker(value any) *shimchecker.Checker {
-  if cast, ok := value.(*shimchecker.Checker); ok {
-    return cast
-  }
-  return nil
-}
+package transform
+
+import (
+  "sync"
+
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimchecker "github.com/microsoft/typescript-go/shim/checker"
+  shimcore "github.com/microsoft/typescript-go/shim/core"
+  shimprinter "github.com/microsoft/typescript-go/shim/printer"
+  "github.com/samchon/ttsc/packages/ttsc/driver"
+  nativecontext "github.com/samchon/typia/packages/typia/native/core/context"
+)
+
+type fileTransformerNamespace struct{}
+
+var FileTransformer = fileTransformerNamespace{}
+
+type FileTransformer_IEnvironments struct {
+  Program         any
+  CompilerOptions any
+  Checker         any
+  Options         nativecontext.ITransformOptions
+  Extras          nativecontext.ITypiaContext_Extras
+  // EmitContext, when set, puts the importer into AST-integration mode so the
+  // emitted file carries namespace imports that tsgo's module-transform aliases,
+  // instead of bare identifiers meant for the legacy text-splice path.
+  EmitContext *shimprinter.EmitContext
+}
+
+type FileTransformer_Type func(file *shimast.SourceFile) *shimast.SourceFile
+
+var fileTransformer_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
+var fileTransformer_jsDocParsingMode sync.Map
+
+func (fileTransformerNamespace) Transform(environments FileTransformer_IEnvironments) func(transformer any) FileTransformer_Type {
+  return func(transformer any) FileTransformer_Type {
+    return func(file *shimast.SourceFile) *shimast.SourceFile {
+      if file == nil || file.IsDeclarationFile {
+        return file
+      }
+      importer := nativecontext.NewImportProgrammer(nativecontext.ImportProgrammer_IOptions{
+        InternalPrefix: "typia_transform_",
+        Runtime:        environments.Options.Runtime,
+      })
+      if environments.EmitContext != nil {
+        importer.SetEmitContext(environments.EmitContext)
+      }
+      context := nativecontext.ITypiaContext{
+        Program:         fileTransformer_program(environments.Program),
+        CompilerOptions: fileTransformer_compilerOptions(environments.CompilerOptions),
+        Checker:         fileTransformer_checker(environments.Checker),
+        Options:         environments.Options,
+        Emit:            environments.EmitContext,
+        Importer:        importer,
+        Extras:          environments.Extras,
+      }
+      _ = transformer
+      fileTransformer_checkJsDocParsingMode(context, file)
+      visited := fileTransformer_iterate_file(context, file)
+      result := fileTransformer_inject_imports(visited, importer.ToStatements(), environments.EmitContext)
+      return result
+    }
+  }
+}
+
+func fileTransformer_iterate_file(context nativecontext.ITypiaContext, file *shimast.SourceFile) *shimast.SourceFile {
+  var visitor *shimast.NodeVisitor
+  visit := func(node *shimast.Node) *shimast.Node {
+    if node == nil {
+      return nil
+    }
+    next := fileTransformer_try_transform_node(FileTransformer_TryTransformNodeProps{
+      Context: context,
+      File:    file,
+      Node:    node,
+    })
+    if next == nil {
+      next = node
+    }
+    return visitor.VisitEachChild(next)
+  }
+  // Traverse with the emit context when available. Recreated ancestor nodes then
+  // retain original parse-tree links, which lets tsgo's emit resolver recover
+  // binder symbols and lower exported namespaces correctly. The standalone
+  // factory loses those links, so module exports can disappear silently.
+  if context.Emit != nil {
+    visitor = context.Emit.NewNodeVisitor(visit)
+  } else {
+    visitor = shimast.NewNodeVisitor(visit, fileTransformer_factory, shimast.NodeVisitorHooks{})
+  }
+  output := visitor.VisitNode(file.AsNode())
+  if output == nil {
+    return file
+  }
+  return output.AsSourceFile()
+}
+
+type FileTransformer_TryTransformNodeProps struct {
+  Context nativecontext.ITypiaContext
+  File    *shimast.SourceFile
+  Node    *shimast.Node
+}
+
+func fileTransformer_try_transform_node(props FileTransformer_TryTransformNodeProps) (output *shimast.Node) {
+  defer func() {
+    if exp := recover(); exp != nil {
+      // typia raises a TransformerError to report a user-facing transform error
+      // (e.g. `typia.llm.schema<Record<...>>` whose argument is not a literal
+      // object). core/programmers panic nativecontext.TransformerError while
+      // transform/features panic the transform-layer alias; both must turn into
+      // a diagnostic, not a repanic that kills the whole emit (the legacy text
+      // adapter swallowed every panic, so the node path must at least handle
+      // both error types).
+      switch err := exp.(type) {
+      case *TransformerError:
+        fileTransformer_addDiagnostic(props, err.Code, err.Message)
+        output = nil
+        return
+      case *nativecontext.TransformerError:
+        fileTransformer_addDiagnostic(props, err.Code, err.Message)
+        output = nil
+        return
+      }
+      panic(exp)
+    }
+  }()
+  return NodeTransformer.Transform(NodeTransformer_TransformProps{
+    Context: props.Context,
+    Node:    props.Node,
+  })
+}
+
+func fileTransformer_addDiagnostic(props FileTransformer_TryTransformNodeProps, code string, message string) {
+  if props.Context.Extras.AddDiagnostic == nil {
+    return
+  }
+  text := "typia transform error"
+  if message != "" {
+    text += ": " + message
+  }
+  diag := &nativecontext.ITypiaDiagnostic{
+    File:    props.File,
+    Code:    code,
+    Message: text,
+  }
+  if props.Node != nil {
+    if pos := props.Node.Pos(); pos >= 0 {
+      diag.Start = &pos
+      if end := props.Node.End(); end >= pos {
+        length := end - pos
+        diag.Length = &length
+      }
+    }
+  }
+  props.Context.Extras.AddDiagnostic(diag)
+}
+
+func fileTransformer_inject_imports(file *shimast.SourceFile, imports []*shimast.Node, emit ...*shimprinter.EmitContext) *shimast.SourceFile {
+  if file == nil || len(imports) == 0 {
+    return file
+  }
+  f := nativecontext.EmitFactoryOf(fileTransformer_factory, emit...)
+  index := fileTransformer_find_import_injection_index(file)
+  nodes := make([]*shimast.Node, 0, len(file.Statements.Nodes)+len(imports))
+  nodes = append(nodes, file.Statements.Nodes[:index]...)
+  nodes = append(nodes, imports...)
+  nodes = append(nodes, file.Statements.Nodes[index:]...)
+  return f.UpdateSourceFile(
+    file,
+    f.NewNodeList(nodes),
+    file.EndOfFileToken,
+  ).AsSourceFile()
+}
+
+func fileTransformer_find_import_injection_index(file *shimast.SourceFile) int {
+  i := 0
+  for ; i < len(file.Statements.Nodes); i++ {
+    stmt := file.Statements.Nodes[i]
+    if stmt == nil || stmt.Kind != shimast.KindExpressionStatement {
+      break
+    }
+    expression := stmt.AsExpressionStatement().Expression
+    if expression == nil || expression.Kind != shimast.KindStringLiteral {
+      break
+    }
+    if text := expression.AsStringLiteral().Text; len(text) < 4 || text[:4] != "use " {
+      break
+    }
+  }
+  return i
+}
+
+func fileTransformer_checkJsDocParsingMode(context nativecontext.ITypiaContext, file *shimast.SourceFile) {
+  if file == nil || context.Extras.AddDiagnostic == nil {
+    return
+  }
+  if _, loaded := fileTransformer_jsDocParsingMode.LoadOrStore(file.FileName(), struct{}{}); loaded {
+    return
+  }
+}
+
+func fileTransformer_program(value any) *driver.Program {
+  if cast, ok := value.(*driver.Program); ok {
+    return cast
+  }
+  return nil
+}
+
+func fileTransformer_compilerOptions(value any) *shimcore.CompilerOptions {
+  if cast, ok := value.(*shimcore.CompilerOptions); ok {
+    return cast
+  }
+  return nil
+}
+
+func fileTransformer_checker(value any) *shimchecker.Checker {
+  if cast, ok := value.(*shimchecker.Checker); ok {
+    return cast
+  }
+  return nil
+}

package/native/transform/ITransformProps.go

@@ -1,5 +1,5 @@
-package transform
-
-import nativeinternal "github.com/samchon/typia/packages/typia/native/transform/internal"
-
-type ITransformProps = nativeinternal.ITransformProps
+package transform
+
+import nativeinternal "github.com/samchon/typia/packages/typia/native/transform/internal"
+
+type ITransformProps = nativeinternal.ITransformProps