typia 13.0.0-dev.20260601.1 → 13.0.0-dev.20260605.1

package/native/adapter/adapter.go

@@ -1,17 +1,7 @@
 package adapter
 
 import (
-  "fmt"
-  "os"
-  "runtime/debug"
-  "strings"
-
-  shimast "github.com/microsoft/typescript-go/shim/ast"
-  "github.com/samchon/ttsc/packages/ttsc/driver"
   nativecontext "github.com/samchon/typia/packages/typia/native/core/context"
-  nativeprogrammers "github.com/samchon/typia/packages/typia/native/core/programmers"
-  nativeprinter "github.com/samchon/typia/packages/typia/native/internal/printer"
-  nativetransform "github.com/samchon/typia/packages/typia/native/transform"
 )
 
 type PluginOptions struct {
@@ -37,196 +27,3 @@ func boolPointer(value bool) *bool {
   }
   return &value
 }
-
-func EmitCallWithOptions(program *driver.Program, site CallSite, plugin PluginOptions) (text string, handled bool, err error) {
-  return emitCallWithOptions(program, site, plugin, false)
-}
-
-func EmitCallWithOptionsPreservingTypes(program *driver.Program, site CallSite, plugin PluginOptions) (text string, handled bool, err error) {
-  return emitCallWithOptions(program, site, plugin, true)
-}
-
-func emitCallWithOptions(program *driver.Program, site CallSite, plugin PluginOptions, preserveTypes bool) (text string, handled bool, err error) {
-  if program == nil || program.Checker == nil || site.Call == nil {
-    return "", false, nil
-  }
-  importer := nativeprogrammers.NewImportProgrammer(nativeprogrammers.ImportProgrammer_IOptions{
-    InternalPrefix: "typia_transform_",
-    Runtime:        "typia",
-  })
-  context := nativecontext.ITypiaContext{
-    Program:         program,
-    CompilerOptions: program.ParsedConfig.ParsedConfig.CompilerOptions,
-    Checker:         program.Checker,
-    Options:         plugin.TransformOptions(),
-    Importer:        importer,
-  }
-  defer func() {
-    if exp := recover(); exp != nil {
-      if e, ok := exp.(*nativetransform.TransformerError); ok {
-        text = ""
-        handled = true
-        err = e
-        return
-      }
-      text = ""
-      handled = true
-      if os.Getenv("TYPIA_NATIVE_DEBUG_STACK") != "" {
-        err = fmt.Errorf("%v\n%s", exp, debug.Stack())
-      } else {
-        err = fmt.Errorf("%v", exp)
-      }
-    }
-  }()
-  var node *shimast.Node
-  if site.Module != "" && site.Method != "" {
-    node = nativetransform.CallExpressionTransformer.TransformKnown(nativetransform.CallExpressionTransformer_TransformKnownProps{
-      Context:    context,
-      Expression: site.Call,
-      Module:     site.Module,
-      Method:     site.Method,
-    })
-  } else {
-    node = nativetransform.CallExpressionTransformer.Transform(nativetransform.CallExpressionTransformer_TransformProps{
-      Context:    context,
-      Expression: site.Call,
-    })
-  }
-  if node == nil || node == site.Call.AsNode() {
-    return "", false, nil
-  }
-  if preserveTypes {
-    return cleanupPrintedExpression(nativeprinter.EmitPreservingTypesWithIdentifierSubstitutions(
-      node,
-      site.File,
-      nil,
-    )), true, nil
-  }
-  return cleanupPrintedExpression(nativeprinter.EmitWithIdentifierSubstitutions(
-    node,
-    site.File,
-    identifierSubstitutionsForEmit(program, site.File),
-  )), true, nil
-}
-
-func identifierSubstitutionsForEmit(program *driver.Program, file any) map[string]string {
-  if program == nil ||
-    program.ParsedConfig == nil ||
-    program.ParsedConfig.ParsedConfig == nil ||
-    program.ParsedConfig.ParsedConfig.CompilerOptions == nil ||
-    program.ParsedConfig.ParsedConfig.CompilerOptions.GetEmitModuleKind().String() != "CommonJS" {
-    return nil
-  }
-  sourceFile, ok := file.(*shimast.SourceFile)
-  if ok == false {
-    return nil
-  }
-  return commonJSImportIdentifierSubstitutions(sourceFile)
-}
-
-func cleanupPrintedExpression(text string) string {
-  text = strings.TrimSpace(text)
-  text = strings.TrimSuffix(text, ";")
-  text = parenthesizeSingleParameterArrows(text)
-  if strings.HasPrefix(text, "(") && strings.HasSuffix(text, ")") {
-    return text
-  }
-  if strings.Contains(text, "=>") || strings.Contains(text, "function") {
-    return "(" + text + ")"
-  }
-  return text
-}
-
-// parenthesizeSingleParameterArrows wraps a bare single-parameter arrow head
-// `x =>` into `(x) =>`. It reproduces the regex
-// `(^|[\s(=,:?])([A-Za-z_$][A-Za-z0-9_$]*) =>` -> `${1}(${2}) =>` with a manual
-// byte scan: the printed call-site expression is large and this pass ran on
-// every site, where the regex backtracker dominated the cleanup CPU.
-func parenthesizeSingleParameterArrows(text string) string {
-  arrow := strings.Index(text, " =>")
-  if arrow < 0 {
-    return text
-  }
-  var b strings.Builder
-  last := 0
-  for arrow >= 0 {
-    end := arrow // identifier ends just before the space of " =>"
-    start := end
-    for start > 0 && isArrowIdentByte(text[start-1]) {
-      start--
-    }
-    if end > start && isArrowIdentStart(text[start]) &&
-      (start == 0 || isArrowBoundaryByte(text[start-1])) {
-      if b.Cap() == 0 {
-        b.Grow(len(text) + 16)
-      }
-      b.WriteString(text[last:start])
-      b.WriteByte('(')
-      b.WriteString(text[start:end])
-      b.WriteByte(')')
-      last = end
-    }
-    next := strings.Index(text[arrow+3:], " =>")
-    if next < 0 {
-      break
-    }
-    arrow += 3 + next
-  }
-  if last == 0 {
-    return text
-  }
-  b.WriteString(text[last:])
-  return b.String()
-}
-
-func isArrowIdentStart(c byte) bool {
-  return c == '_' || c == '$' ||
-    (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')
-}
-
-func isArrowIdentByte(c byte) bool {
-  return isArrowIdentStart(c) || (c >= '0' && c <= '9')
-}
-
-// isArrowBoundaryByte matches the regex class [\s(=,:?] (RE2 `\s` is
-// [\t\n\f\r ], i.e. no vertical tab).
-func isArrowBoundaryByte(c byte) bool {
-  switch c {
-  case ' ', '\t', '\n', '\f', '\r', '(', '=', ',', ':', '?':
-    return true
-  }
-  return false
-}
-
-func UnsupportedReason(site CallSite) string {
-  if site.Call == nil {
-    return "invalid call expression"
-  }
-  if site.Call.TypeArguments == nil || len(site.Call.TypeArguments.Nodes) == 0 {
-    switch site.Module {
-    case "module":
-      switch site.Method {
-      case "assert", "assertEquals", "assertGuard", "assertGuardEquals", "assertType", "equals", "is", "validate", "validateEquals":
-        return ""
-      }
-    case "json":
-      switch site.Method {
-      case "stringify", "assertStringify", "isStringify", "validateStringify":
-        return ""
-      }
-    }
-    return "generic argument is not specified."
-  }
-  return ""
-}
-
-func FormatTransformError(site CallSite, err error) string {
-  if err == nil {
-    return ""
-  }
-  code := "typia." + site.Method
-  if site.Module != "" {
-    code = "typia." + site.Module + "." + site.Method
-  }
-  return fmt.Sprintf("error TS(%s): %s", code, err.Error())
-}

package/native/cmd/ttsc-typia/build.go

@@ -9,10 +9,13 @@ import (
   "path/filepath"
   "regexp"
 
+  shimast "github.com/microsoft/typescript-go/shim/ast"
   shimcompiler "github.com/microsoft/typescript-go/shim/compiler"
-  shimscanner "github.com/microsoft/typescript-go/shim/scanner"
+  shimprinter "github.com/microsoft/typescript-go/shim/printer"
   "github.com/samchon/ttsc/packages/ttsc/driver"
   typiaadapter "github.com/samchon/typia/packages/typia/native/adapter"
+  nativecontext "github.com/samchon/typia/packages/typia/native/core/context"
+  nativetransform "github.com/samchon/typia/packages/typia/native/transform"
 )
 
 func runBuild(args []string) int {
@@ -71,30 +74,35 @@ func runBuild(args []string) int {
     return 2
   }
 
-  rewrites := driver.NewRewriteSet()
-  transformDiags := []typiaTransformDiagnostic{}
-  sites, recognized := 0, 0
   shouldEmit := !prog.ParsedConfig.ParsedConfig.CompilerOptions.NoEmit.IsTrue()
-  if *rewriteMode == "typia" {
-    sites, recognized, transformDiags = collectTypiaRewrites(
-      prog,
-      cwd,
-      shouldEmit,
-      *quiet,
-      "",
-      rewrites,
-      readTypiaPluginOptions(cwd, *tsconfigPath),
-    )
+  transformDiags := []typiaTransformDiagnostic{}
+  pluginOptions := readTypiaPluginOptions(cwd, *tsconfigPath)
+  transformOptions := pluginOptions.TransformOptions()
+  extras := nativecontext.ITypiaContext_Extras{
+    AddDiagnostic: func(diag *shimast.Diagnostic) int {
+      transformDiags = append(transformDiags, typiaTransformDiagnostic{Message: "typia transform error"})
+      return len(transformDiags)
+    },
+  }
+  // AST-integration emit: typia's per-file transformer runs inside tsgo's emit
+  // pipeline (sharing the EmitContext), so it returns AST and tsgo's module-
+  // transform aliases the injected namespace imports. No text-splice RewriteSet.
+  typiaTransform := func(ec *shimprinter.EmitContext, sf *shimast.SourceFile) *shimast.SourceFile {
+    if *rewriteMode != "typia" {
+      return sf
+    }
+    return nativetransform.Transform(prog, &transformOptions, extras, ec)(sf)
   }
   if !*quiet {
-    fmt.Fprintf(stdout, "// ttsc-typia build: tsconfig=%s cwd=%s sites=%d emit=%v rewrite=%s\n", *tsconfigPath, cwd, sites, shouldEmit, *rewriteMode)
+    fmt.Fprintf(stdout, "// ttsc-typia build: tsconfig=%s cwd=%s emit=%v rewrite=%s\n", *tsconfigPath, cwd, shouldEmit, *rewriteMode)
   }
   if shouldEmit {
+    emitted := []string{}
     writeFile := shimcompiler.WriteFile(func(fileName, text string, data *shimcompiler.WriteFileData) error {
-      text = typiaadapter.CleanupTransformedText(text)
+      emitted = append(emitted, fileName)
       return driver.DefaultWriteFile(fileName, text)
     })
-    res, eDiags, err := prog.EmitAll(rewrites, writeFile)
+    eDiags, err := prog.EmitWithPluginTransformers([]driver.PluginTransform{typiaTransform}, writeFile)
     if err != nil {
       fmt.Fprintf(stderr, "ttsc-typia build: emit failed: %v\n", err)
       return 3
@@ -103,8 +111,8 @@ func runBuild(args []string) int {
       fmt.Fprintln(stderr, "  -", d.String())
     }
     if !*quiet {
-      fmt.Fprintf(stdout, "// ttsc-typia build: emitted=%d files\n", len(res.EmittedFiles))
-      for _, f := range res.EmittedFiles {
+      fmt.Fprintf(stdout, "// ttsc-typia build: emitted=%d files\n", len(emitted))
+      for _, f := range emitted {
         rel := f
         if abs, err := filepath.Rel(cwd, f); err == nil {
           rel = abs
@@ -113,7 +121,7 @@ func runBuild(args []string) int {
       }
     }
     if *manifestPath != "" {
-      data, err := json.Marshal(res.EmittedFiles)
+      data, err := json.Marshal(emitted)
       if err != nil {
         fmt.Fprintf(stderr, "ttsc-typia build: manifest marshal failed: %v\n", err)
         return 3
@@ -132,9 +140,6 @@ func runBuild(args []string) int {
     writeTypiaTransformDiagnostics(stderr, transformDiags, cwd)
     return 3
   }
-  if !*quiet {
-    fmt.Fprintf(stdout, "// ttsc-typia build: recognized=%d total=%d rewrites=%d\n", recognized, sites, rewrites.Len())
-  }
   return 0
 }
 
@@ -163,73 +168,6 @@ func writeTypiaTransformDiagnostics(out io.Writer, diagnostics []typiaTransformD
   }
 }
 
-func newTypiaTransformDiagnostic(site typiaadapter.CallSite, message string) typiaTransformDiagnostic {
-  line, column := 0, 0
-  if site.File != nil && site.Call != nil {
-    pos := site.Call.AsNode().Pos()
-    if pos >= 0 {
-      l, c := shimscanner.GetECMALineAndByteOffsetOfPosition(site.File, pos)
-      line, column = l+1, c+1
-    }
-  }
-  return typiaTransformDiagnostic{
-    File:    site.FilePath,
-    Line:    line,
-    Column:  column,
-    Code:    "typia." + site.Module + "." + site.Method,
-    Message: message,
-  }
-}
-
-func collectTypiaRewrites(
-  prog *driver.Program,
-  cwd string,
-  emit bool,
-  quiet bool,
-  onlyFile string,
-  rewrites *driver.RewriteSet,
-  pluginOptions typiaadapter.PluginOptions,
-) (int, int, []typiaTransformDiagnostic) {
-  sites := typiaadapter.CollectCallSites(prog.SourceFiles(), prog.Checker)
-  recognized := 0
-  diagnostics := []typiaTransformDiagnostic{}
-  for _, site := range sites {
-    if onlyFile != "" && filepath.ToSlash(site.FilePath) != filepath.ToSlash(onlyFile) {
-      continue
-    }
-    rel := site.FilePath
-    if abs, err := filepath.Rel(cwd, rel); err == nil {
-      rel = abs
-    }
-    if reason := typiaadapter.UnsupportedReason(site); reason != "" {
-      diagnostics = append(diagnostics, newTypiaTransformDiagnostic(site, reason))
-      continue
-    }
-    expr, handled, err := typiaadapter.EmitCallWithOptions(prog, site, pluginOptions)
-    if !handled {
-      diagnostics = append(diagnostics, newTypiaTransformDiagnostic(site, "method not covered"))
-      continue
-    }
-    if err != nil {
-      diagnostics = append(diagnostics, newTypiaTransformDiagnostic(site, err.Error()))
-      continue
-    }
-    rewrites.Add(driver.Rewrite{
-      File:          site.File,
-      RootName:      site.RootName,
-      Namespaces:    site.Namespaces,
-      Method:        site.Method,
-      Replacement:   expr,
-      ConsumeParens: true,
-    })
-    if !emit && !quiet {
-      fmt.Fprintf(stdout, "%s: typia.%s<T> -> %s\n", rel, site.Method, expr)
-    }
-    recognized++
-  }
-  return len(sites), recognized, diagnostics
-}
-
 func readTypiaPluginOptions(cwd, tsconfigPath string) typiaadapter.PluginOptions {
   path := tsconfigPath
   if !filepath.IsAbs(path) {

package/native/cmd/ttsc-typia/main.go

@@ -41,10 +41,10 @@ func run(args []string) int {
     return runDemo(args[1:])
   case "build":
     return runBuild(args[1:])
-  case "check":
-    return runBuild(append([]string{"--noEmit"}, args[1:]...))
   case "transform":
     return runTransform(args[1:])
+  case "check":
+    return runBuild(append([]string{"--noEmit"}, args[1:]...))
   case "-p", "--project":
     if len(args) < 2 {
       fmt.Fprintln(stderr, "ttsc-typia: -p/--project requires a path argument")