ttsc 0.9.0 → 0.10.0

package/utility/host.go

@@ -13,6 +13,7 @@ import (
   shimast "github.com/microsoft/typescript-go/shim/ast"
   shimcompiler "github.com/microsoft/typescript-go/shim/compiler"
   shimcore "github.com/microsoft/typescript-go/shim/core"
+  shimprinter "github.com/microsoft/typescript-go/shim/printer"
 
   "github.com/samchon/ttsc/packages/ttsc/driver"
 )
@@ -108,14 +109,19 @@ func RunTransform(args []string) int {
   if !ok {
     return 2
   }
-  prog, _, _, _, ok := loadUtilityProgram(opts)
+  prog, _, _, sourcePreamble, ok := loadUtilityProgram(opts)
   if !ok {
     return 2
   }
   defer prog.Close()
+  printer := shimprinter.NewPrinter(shimprinter.PrinterOptions{}, shimprinter.PrintHandlers{}, nil)
   out := transformResult{TypeScript: map[string]string{}}
   for _, file := range prog.SourceFiles() {
-    out.TypeScript[apiOutputKey(opts.cwd, file.FileName())] = file.Text()
+    text := shimprinter.EmitSourceFile(printer, file)
+    if sourcePreamble != "" && !shouldRemoveComments(prog) && !strings.Contains(text, sourcePreamble) {
+      text = driver.ApplySourcePreamble(text, sourcePreamble)
+    }
+    out.TypeScript[apiOutputKey(opts.cwd, file.FileName())] = text
   }
   data, err := json.Marshal(out)
   if err != nil {
@@ -140,6 +146,10 @@ func parseHostOptions(command string, args []string) (hostOptions, bool) {
   if err := fs.Parse(filterHostArgs(args)); err != nil {
     return hostOptions{}, false
   }
+  if *emit && *noEmit {
+    fmt.Fprintln(os.Stderr, "ttsc utility: --emit and --noEmit are mutually exclusive")
+    return hostOptions{}, false
+  }
   resolvedCwd := *cwd
   if resolvedCwd == "" {
     var err error

package/cmd/ttsc/main_test.go

@@ -1,288 +0,0 @@
-package main
-
-import (
-  "bytes"
-  "os"
-  "path/filepath"
-  "strings"
-  "testing"
-)
-
-// withCapture replaces stdout/stderr with buffers for the duration of fn.
-// Keeps each test hermetic.
-func withCapture(fn func()) (out, errOut string) {
-  var outBuf, errBuf bytes.Buffer
-  prevOut, prevErr := stdout, stderr
-  stdout = &outBuf
-  stderr = &errBuf
-  defer func() {
-    stdout = prevOut
-    stderr = prevErr
-  }()
-  fn()
-  return outBuf.String(), errBuf.String()
-}
-
-func TestRunNoArgsAttemptsProjectBuild(t *testing.T) {
-  out, errOut := withCapture(func() {
-    if code := run(nil); code == 0 {
-      t.Errorf("expected no-args run without a local tsconfig to fail")
-    }
-  })
-  if strings.Contains(out, "Usage:") {
-    t.Errorf("no-args ttsc must build the project, not print help; got %q", out)
-  }
-  if !strings.Contains(errOut, "tsconfig") {
-    t.Errorf("expected no-args build to look for tsconfig, got stderr %q", errOut)
-  }
-}
-
-func TestRunHelpVariants(t *testing.T) {
-  for _, flag := range []string{"-h", "--help", "help"} {
-    t.Run(flag, func(t *testing.T) {
-      out, _ := withCapture(func() {
-        if code := run([]string{flag}); code != 0 {
-          t.Errorf("expected exit 0, got %d", code)
-        }
-      })
-      if !strings.Contains(out, "demo") {
-        t.Errorf("help text should list demo subcommand, got %q", out)
-      }
-    })
-  }
-}
-
-func TestRunVersion(t *testing.T) {
-  for _, flag := range []string{"-v", "--version", "version"} {
-    t.Run(flag, func(t *testing.T) {
-      out, _ := withCapture(func() {
-        if code := run([]string{flag}); code != 0 {
-          t.Errorf("expected exit 0, got %d", code)
-        }
-      })
-      if !strings.Contains(out, "ttsc ") {
-        t.Errorf("expected version banner, got %q", out)
-      }
-      // Include useful debug bits
-      for _, tag := range []string{"commit", "go"} {
-        if !strings.Contains(out, tag) {
-          t.Errorf("expected %q substring in version output, got %q", tag, out)
-        }
-      }
-    })
-  }
-}
-
-func TestRunUnknownCommandExits2(t *testing.T) {
-  _, errOut := withCapture(func() {
-    if code := run([]string{"fly-to-mars"}); code != 2 {
-      t.Errorf("expected exit 2, got %d", code)
-    }
-  })
-  if !strings.Contains(errOut, "unknown command") {
-    t.Errorf("expected error text, got %q", errOut)
-  }
-}
-
-func TestRunBuildBlocksSemanticDiagnosticsBeforeEmit(t *testing.T) {
-  root := t.TempDir()
-  writeProjectFile(t, root, "tsconfig.json", `{
-  "compilerOptions": {
-    "module": "commonjs",
-    "target": "es2020",
-    "outDir": "bin",
-    "strict": true
-  }
-}
-`)
-  writeProjectFile(t, root, "index.ts", `const value: string = 123;
-console.log(value);
-`)
-
-  _, errOut := withCapture(func() {
-    if code := runBuild([]string{"--cwd", root, "--emit"}); code != 2 {
-      t.Errorf("expected exit 2, got %d", code)
-    }
-  })
-  if !strings.Contains(errOut, "Type 'number' is not assignable to type 'string'") {
-    t.Errorf("expected semantic diagnostic, got %q", errOut)
-  }
-  if !strings.Contains(errOut, "\x1b[91merror\x1b[0m") || !strings.Contains(errOut, "TS2322") {
-    t.Errorf("expected colored TypeScript-style diagnostic header, got %q", errOut)
-  }
-  if !strings.Contains(errOut, "\x1b[7m1\x1b[0m") || !strings.Contains(errOut, "~~~~~") {
-    t.Errorf("expected source context with highlighted span, got %q", errOut)
-  }
-  if _, err := os.Stat(filepath.Join(root, "bin", "index.js")); !os.IsNotExist(err) {
-    t.Errorf("expected no emitted JS, stat err=%v", err)
-  }
-}
-
-func TestRunBuildAllowsUnusedTypeParametersOnOverloadSignatures(t *testing.T) {
-  root := t.TempDir()
-  writeProjectFile(t, root, "tsconfig.json", `{
-  "compilerOptions": {
-    "module": "commonjs",
-    "target": "es2020",
-    "outDir": "bin",
-    "strict": true,
-    "noUnusedLocals": true,
-    "noUnusedParameters": true
-  }
-}
-`)
-  writeProjectFile(t, root, "index.ts", `export function marker<T>(input: unknown): string;
-export function marker(input: unknown): string {
-  return String(input);
-}
-`)
-
-  _, errOut := withCapture(func() {
-    if code := runBuild([]string{"--cwd", root, "--emit", "--quiet"}); code != 0 {
-      t.Errorf("expected exit 0, got %d", code)
-    }
-  })
-  if strings.Contains(errOut, "declared but never used") || strings.Contains(errOut, "All type parameters are unused") {
-    t.Errorf("overload signature type parameters must not fail noUnused checks, got %q", errOut)
-  }
-  if _, err := os.Stat(filepath.Join(root, "bin", "index.js")); err != nil {
-    t.Errorf("expected emitted JS, stat err=%v", err)
-  }
-}
-
-func TestRunBuildBlocksUnusedParametersBeforeEmit(t *testing.T) {
-  root := t.TempDir()
-  writeProjectFile(t, root, "tsconfig.json", `{
-  "compilerOptions": {
-    "module": "commonjs",
-    "target": "es2020",
-    "outDir": "bin",
-    "strict": true,
-    "noUnusedParameters": true
-  }
-}
-`)
-  writeProjectFile(t, root, "index.ts", `export function run(unused: string): number {
-  return 1;
-}
-`)
-
-  _, errOut := withCapture(func() {
-    if code := runBuild([]string{"--cwd", root, "--emit"}); code != 2 {
-      t.Errorf("expected exit 2, got %d", code)
-    }
-  })
-  if !strings.Contains(errOut, "'unused' is declared but its value is never read") &&
-    !strings.Contains(errOut, "'unused' is declared but never used") {
-    t.Errorf("expected unused parameter diagnostic, got %q", errOut)
-  }
-  if _, err := os.Stat(filepath.Join(root, "bin", "index.js")); !os.IsNotExist(err) {
-    t.Errorf("expected no emitted JS, stat err=%v", err)
-  }
-}
-
-func TestRunBuildBlocksSyntacticDiagnosticsBeforeEmit(t *testing.T) {
-  root := t.TempDir()
-  writeProjectFile(t, root, "tsconfig.json", `{
-  "compilerOptions": {
-    "module": "commonjs",
-    "target": "es2020",
-    "outDir": "bin"
-  }
-}
-`)
-  writeProjectFile(t, root, "index.ts", `console.log("before");
-const = ;
-`)
-
-  _, errOut := withCapture(func() {
-    if code := runBuild([]string{"--cwd", root, "--emit"}); code != 2 {
-      t.Errorf("expected exit 2, got %d", code)
-    }
-  })
-  if !strings.Contains(errOut, "Variable declaration expected") {
-    t.Errorf("expected syntactic diagnostic, got %q", errOut)
-  }
-  if _, err := os.Stat(filepath.Join(root, "bin", "index.js")); !os.IsNotExist(err) {
-    t.Errorf("expected no emitted JS, stat err=%v", err)
-  }
-}
-
-func writeProjectFile(t *testing.T, root string, name string, contents string) {
-  t.Helper()
-  file := filepath.Join(root, name)
-  if err := os.MkdirAll(filepath.Dir(file), 0o755); err != nil {
-    t.Fatal(err)
-  }
-  if err := os.WriteFile(file, []byte(contents), 0o644); err != nil {
-    t.Fatal(err)
-  }
-}
-
-func TestRunDemoString(t *testing.T) {
-  out, _ := withCapture(func() {
-    if code := run([]string{"demo", "--type=string"}); code != 0 {
-      t.Errorf("expected exit 0, got %d", code)
-    }
-  })
-  want := `(input) => "string" === typeof input`
-  if !strings.Contains(out, want) {
-    t.Errorf("expected demo output to contain %q, got:\n%s", want, out)
-  }
-  if !strings.Contains(out, "demo<string>") {
-    t.Errorf("expected comment prefix in demo output, got:\n%s", out)
-  }
-}
-
-func TestRunDemoEveryAtomic(t *testing.T) {
-  cases := map[string]string{
-    "boolean": `"boolean" === typeof input`,
-    "number":  `"number" === typeof input`,
-    "bigint":  `"bigint" === typeof input`,
-    "any":     `(input) => true`,
-  }
-  for typ, expected := range cases {
-    t.Run(typ, func(t *testing.T) {
-      out, _ := withCapture(func() {
-        if code := run([]string{"demo", "--type=" + typ}); code != 0 {
-          t.Errorf("expected exit 0 for %s, got %d", typ, code)
-        }
-      })
-      if !strings.Contains(out, expected) {
-        t.Errorf("for --type=%s, want %q in output:\n%s", typ, expected, out)
-      }
-    })
-  }
-}
-
-func TestRunDemoUnknownTypeExits2(t *testing.T) {
-  _, errOut := withCapture(func() {
-    if code := run([]string{"demo", "--type=object"}); code != 2 {
-      t.Errorf("expected exit 2 for unknown type, got %d", code)
-    }
-  })
-  if !strings.Contains(errOut, "unknown --type") {
-    t.Errorf("expected diagnostic text, got %q", errOut)
-  }
-}
-
-func TestDemoArrowEveryAtomic(t *testing.T) {
-  cases := map[string]string{
-    "string":  `"string" === typeof input`,
-    "number":  `"number" === typeof input`,
-    "boolean": `"boolean" === typeof input`,
-    "bigint":  `"bigint" === typeof input`,
-    "any":     `(input) => true`,
-  }
-  for name, want := range cases {
-    t.Run(name, func(t *testing.T) {
-      arrow, err := demoArrow(name)
-      if err != nil {
-        t.Fatalf("unexpected err: %v", err)
-      }
-      if !strings.Contains(arrow, want) {
-        t.Errorf("for %s want %q, got %q", name, want, arrow)
-      }
-    })
-  }
-}

package/driver/rewrite_test.go

@@ -1,52 +0,0 @@
-package driver
-
-import "testing"
-
-func TestSpliceCallConsumesRegexLiteralWithClosingParen(t *testing.T) {
-  got := spliceForTest(t, `const out = plugin.make(/\)/, "ok");`)
-  want := `const out = replacement;`
-  if got != want {
-    t.Fatalf("unexpected rewrite:\nwant: %s\n got: %s", want, got)
-  }
-}
-
-func TestSpliceCallIgnoresClosingParenInsideBlockComment(t *testing.T) {
-  got := spliceForTest(t, `const out = plugin.make(1 /* ) */, 2);`)
-  want := `const out = replacement;`
-  if got != want {
-    t.Fatalf("unexpected rewrite:\nwant: %s\n got: %s", want, got)
-  }
-}
-
-func TestSpliceCallIgnoresClosingParenInsideLineComment(t *testing.T) {
-  got := spliceForTest(t, "const out = plugin.make(\n  1, // )\n  2\n);")
-  want := `const out = replacement;`
-  if got != want {
-    t.Fatalf("unexpected rewrite:\nwant: %s\n got: %s", want, got)
-  }
-}
-
-func TestSpliceCallKeepsDivisionOutsideRegexMode(t *testing.T) {
-  got := spliceForTest(t, `const out = plugin.make(total / divisor, 2);`)
-  want := `const out = replacement;`
-  if got != want {
-    t.Fatalf("unexpected rewrite:\nwant: %s\n got: %s", want, got)
-  }
-}
-
-func spliceForTest(t *testing.T, text string) string {
-  t.Helper()
-  got, _, ok, err := spliceCall(text, Rewrite{
-    RootName:      "plugin",
-    Method:        "make",
-    Replacement:   "replacement",
-    ConsumeParens: true,
-  }, 0)
-  if err != nil {
-    t.Fatal(err)
-  }
-  if !ok {
-    t.Fatal("rewrite did not match")
-  }
-  return got
-}

package/utility/host_test.go

@@ -1,162 +0,0 @@
-package utility
-
-import (
-  "os"
-  "path/filepath"
-  "strings"
-  "testing"
-)
-
-func TestFilterHostArgsKeepsUtilityFlagsAndDropsHostOnlyFlags(t *testing.T) {
-  got := filterHostArgs([]string{
-    "--cwd", "/workspace/project",
-    "--cache-dir", ".ttsc",
-    "--emit",
-    "--binary=/tmp/tsgo",
-    "--plugins-json", "[]",
-    "src/main.ts",
-    "--",
-    "--cwd", "ignored",
-  })
-  want := []string{
-    "--cwd", "/workspace/project",
-    "--emit",
-    "--plugins-json", "[]",
-    "src/main.ts",
-  }
-  if !equalStringSlices(got, want) {
-    t.Fatalf("filtered args mismatch:\nwant: %#v\n got: %#v", want, got)
-  }
-}
-
-func TestParseBannerFormatsAndSanitizesJSDoc(t *testing.T) {
-  banner, err := parseBanner(map[string]any{
-    "text": "first\r\nsecond */\n\n",
-  }, t.TempDir(), "tsconfig.json")
-  if err != nil {
-    t.Fatal(err)
-  }
-  if !strings.Contains(banner, " * first\n * second * /\n") {
-    t.Fatalf("banner was not normalized and sanitized:\n%s", banner)
-  }
-  if strings.Contains(banner, "second */") {
-    t.Fatalf("banner must not preserve raw JSDoc terminator:\n%s", banner)
-  }
-  if !strings.HasSuffix(banner, "*/\n") {
-    t.Fatalf("banner must end with a closed JSDoc block:\n%s", banner)
-  }
-}
-
-func TestFindBannerConfigFileUsesTsconfigDirectoryWhenOutsideCwd(t *testing.T) {
-  cwd := seedHostTestProject(t, map[string]string{
-    "banner.config.cjs": `module.exports = { text: "cwd banner" };` + "\n",
-  })
-  wrapper := seedHostTestProject(t, map[string]string{
-    "banner.config.cjs": `module.exports = { text: "wrapper banner" };` + "\n",
-    "tsconfig.json":     "{}",
-  })
-
-  discovered, err := findBannerConfigFile(cwd, filepath.Join(wrapper, "tsconfig.json"))
-  if err != nil {
-    t.Fatalf("findBannerConfigFile: %v", err)
-  }
-  if discovered != filepath.Join(wrapper, "banner.config.cjs") {
-    t.Fatalf("unexpected discovery path: %s", discovered)
-  }
-}
-
-func TestResolveBannerTextRejectsEmptyObjectText(t *testing.T) {
-  _, err := resolveBannerText(map[string]any{
-    "text": "  ",
-  }, t.TempDir(), "tsconfig.json")
-  if err == nil || !strings.Contains(err.Error(), "non-empty string") {
-    t.Fatalf("expected non-empty string error, got %v", err)
-  }
-}
-
-func TestPathsRewriterResolvesIndexAndModuleExtensions(t *testing.T) {
-  root := normalizePath(t.TempDir())
-  source := normalizePath(filepath.Join(root, "src", "consumer", "main.ts"))
-  index := normalizePath(filepath.Join(root, "src", "modules", "index.ts"))
-  module := normalizePath(filepath.Join(root, "src", "modules", "esm.mts"))
-  rewriter := &pathsRewriter{
-    basePath: root,
-    outDir:   normalizePath(filepath.Join(root, "dist")),
-    rootDir:  normalizePath(filepath.Join(root, "src")),
-    patterns: []pathsPattern{
-      {pattern: "@lib/*", targets: []string{"src/modules/*"}},
-    },
-    sourceFiles: map[string]string{
-      index:                             index,
-      stripKnownSourceExtension(index):  index,
-      module:                            module,
-      stripKnownSourceExtension(module): module,
-    },
-  }
-
-  rewritten, ok := rewriter.rewrite(source, "@lib")
-  if ok || rewritten != "@lib" {
-    t.Fatalf("non-matching pattern should stay unchanged, got %q ok=%v", rewritten, ok)
-  }
-
-  rewritten, ok = rewriter.rewrite(source, "@lib/index")
-  if !ok || rewritten != "../modules/index.js" {
-    t.Fatalf("index rewrite mismatch: %q ok=%v", rewritten, ok)
-  }
-
-  rewritten, ok = rewriter.rewrite(source, "@lib/esm")
-  if !ok || rewritten != "../modules/esm.mjs" {
-    t.Fatalf("module extension rewrite mismatch: %q ok=%v", rewritten, ok)
-  }
-}
-
-func TestStripConfigurationDefaultsAndValidation(t *testing.T) {
-  strip, err := parseStrip(map[string]any{})
-  if err != nil {
-    t.Fatal(err)
-  }
-  if !strip.stripDebugger || !strip.matchesCall("console.log") || !strip.matchesCall("assert.equal") {
-    t.Fatalf("default strip config did not enable expected patterns: %#v", strip)
-  }
-  if strip.matchesCall("console.info") || strip.matchesCall("assert") {
-    t.Fatalf("default strip config matched too broadly")
-  }
-
-  if _, err := parseStrip(map[string]any{"statements": []any{"debugger", "with"}}); err == nil {
-    t.Fatal("unsupported statement pattern must fail")
-  }
-  if _, err := parseCallPattern("assert.*.deep"); err == nil {
-    t.Fatal("middle wildcard call pattern must fail")
-  }
-}
-
-func TestSourceExtensionHelpersPreferCompoundExtensions(t *testing.T) {
-  cases := map[string]string{
-    "types.d.ts":     "types",
-    "types.d.mts":    "types",
-    "module.test.ts": "module.test",
-    "entry.jsx":      "entry",
-  }
-  for input, want := range cases {
-    t.Run(input, func(t *testing.T) {
-      if got := stripKnownSourceExtension(input); got != want {
-        t.Fatalf("stripKnownSourceExtension(%q) = %q, want %q", input, got, want)
-      }
-    })
-  }
-}
-
-func seedHostTestProject(t *testing.T, files map[string]string) string {
-  t.Helper()
-  root := t.TempDir()
-  for name, text := range files {
-    file := filepath.Join(root, filepath.FromSlash(name))
-    if err := os.MkdirAll(filepath.Dir(file), 0o755); err != nil {
-      t.Fatal(err)
-    }
-    if err := os.WriteFile(file, []byte(text), 0o644); err != nil {
-      t.Fatal(err)
-    }
-  }
-  return root
-}