ttsc 0.12.3 → 0.12.4

package/cmd/ttsc/build.go

@@ -8,15 +8,15 @@
 package main
 
 import (
-	"encoding/json"
-	"flag"
-	"fmt"
-	"os"
-	"path/filepath"
+  "encoding/json"
+  "flag"
+  "fmt"
+  "os"
+  "path/filepath"
 
-	shimcompiler "github.com/microsoft/typescript-go/shim/compiler"
+  shimcompiler "github.com/microsoft/typescript-go/shim/compiler"
 
-	"github.com/samchon/ttsc/packages/ttsc/driver"
+  "github.com/samchon/ttsc/packages/ttsc/driver"
 )
 
 // runBuild implements the `ttsc` project-build lane. Two modes:
@@ -25,110 +25,113 @@ import (
 //   - --emit: also run tsgo's emit pipeline, patching every recognized native
 //     consumer call in the resulting .js files.
 func runBuild(args []string) int {
-	fs := flag.NewFlagSet("build", flag.ContinueOnError)
-	fs.SetOutput(stderr)
-	tsconfigPath := fs.String("tsconfig", "tsconfig.json", "path to tsconfig.json")
-	cwdOverride := fs.String("cwd", "", "override the working directory (defaults to process cwd)")
-	quiet := fs.Bool("quiet", true, "suppress the per-call diagnostic summary")
-	verbose := fs.Bool("verbose", false, "print the per-call diagnostic summary")
-	emit := fs.Bool("emit", false, "force emitted .js files (runs tsgo + ttsc rewrite)")
-	noEmit := fs.Bool("noEmit", false, "force analysis-only run with no file writes")
-	outDir := fs.String("outDir", "", "override compilerOptions.outDir for this build")
-	manifestPath := fs.String("manifest", "", "write emitted file list as JSON to this path")
-	if err := fs.Parse(args); err != nil {
-		return 2
-	}
-	if *emit && *noEmit {
-		fmt.Fprintln(stderr, "ttsc: --emit and --noEmit are mutually exclusive")
-		return 2
-	}
-	if *verbose {
-		*quiet = false
-	}
+  fs := flag.NewFlagSet("build", flag.ContinueOnError)
+  fs.SetOutput(stderr)
+  tsconfigPath := fs.String("tsconfig", "tsconfig.json", "path to tsconfig.json")
+  cwdOverride := fs.String("cwd", "", "override the working directory (defaults to process cwd)")
+  quiet := fs.Bool("quiet", true, "suppress the per-call diagnostic summary")
+  verbose := fs.Bool("verbose", false, "print the per-call diagnostic summary")
+  emit := fs.Bool("emit", false, "force emitted .js files (runs tsgo + ttsc rewrite)")
+  noEmit := fs.Bool("noEmit", false, "force analysis-only run with no file writes")
+  outDir := fs.String("outDir", "", "override compilerOptions.outDir for this build")
+  manifestPath := fs.String("manifest", "", "write emitted file list as JSON to this path")
+  if err := fs.Parse(args); err != nil {
+    return 2
+  }
+  if *emit && *noEmit {
+    fmt.Fprintln(stderr, "ttsc: --emit and --noEmit are mutually exclusive")
+    return 2
+  }
+  if *verbose {
+    *quiet = false
+  }
 
-	cwd := *cwdOverride
-	if cwd == "" {
-		var err error
-		cwd, err = getwd()
-		if err != nil {
-			fmt.Fprintf(stderr, "ttsc: could not get working directory: %v\n", err)
-			return 2
-		}
-	}
+  cwd := *cwdOverride
+  if cwd == "" {
+    var err error
+    cwd, err = getwd()
+    if err != nil {
+      fmt.Fprintf(stderr, "ttsc: could not get working directory: %v\n", err)
+      return 2
+    }
+  }
 
-	prog, diags, err := driver.LoadProgram(cwd, *tsconfigPath, driver.LoadProgramOptions{
-		ForceEmit:   *emit,
-		ForceNoEmit: *noEmit,
-		OutDir:      *outDir,
-	})
-	if err != nil {
-		fmt.Fprintf(stderr, "ttsc: %v\n", err)
-		return 2
-	}
-	if len(diags) > 0 {
-		driver.WritePrettyDiagnostics(stderr, diags, cwd)
-		return 2
-	}
-	defer prog.Close()
-	if diags := prog.Diagnostics(); len(diags) > 0 {
-		driver.WritePrettyDiagnostics(stderr, diags, cwd)
-		return 2
-	}
+  prog, diags, err := driver.LoadProgram(cwd, *tsconfigPath, driver.LoadProgramOptions{
+    ForceEmit:   *emit,
+    ForceNoEmit: *noEmit,
+    OutDir:      *outDir,
+  })
+  if err != nil {
+    fmt.Fprintf(stderr, "ttsc: %v\n", err)
+    return 2
+  }
+  if len(diags) > 0 {
+    driver.WritePrettyDiagnostics(stderr, diags, cwd)
+    return 2
+  }
+  defer prog.Close()
+  if diags := prog.Diagnostics(); len(diags) > 0 {
+    driver.WritePrettyDiagnostics(stderr, diags, cwd)
+    return 2
+  }
 
-	rewrites := driver.NewRewriteSet()
-	shouldEmit := !prog.ParsedConfig.ParsedConfig.CompilerOptions.NoEmit.IsTrue()
-	if !*quiet {
-		fmt.Fprintf(stdout, "// ttsc: tsconfig=%s cwd=%s sites=%d emit=%v\n", *tsconfigPath, cwd, 0, shouldEmit)
-	}
+  rewrites := driver.NewRewriteSet()
+  // shouldEmit reflects the resolved tsconfig noEmit flag. The flag lives
+  // three levels deep in the parsed config because TypeScript-Go mirrors the
+  // tsconfig object structure verbatim, with a tri-state bool per option.
+  shouldEmit := !prog.ParsedConfig.ParsedConfig.CompilerOptions.NoEmit.IsTrue()
+  if !*quiet {
+    fmt.Fprintf(stdout, "// ttsc: tsconfig=%s cwd=%s sites=%d emit=%v\n", *tsconfigPath, cwd, 0, shouldEmit)
+  }
 
-	if shouldEmit {
-		// Emit is callback-driven in TypeScript-Go. ttsc keeps that shape and
-		// wraps only the final WriteFile step so native rewrites and custom output
-		// capture share the same path.
-		writeFile := shimcompiler.WriteFile(
-			func(fileName, text string, _ *shimcompiler.WriteFileData) error {
-				return driver.DefaultWriteFile(fileName, text)
-			},
-		)
-		res, eDiags, err := prog.EmitAll(rewrites, writeFile)
-		if err != nil {
-			fmt.Fprintf(stderr, "ttsc: emit failed: %v\n", err)
-			return 3
-		}
-		for _, d := range eDiags {
-			fmt.Fprintln(stderr, "  -", d.String())
-		}
-		if driver.CountErrors(eDiags) > 0 {
-			return 2
-		}
-		if !*quiet {
-			fmt.Fprintf(stdout, "// ttsc: emitted=%d files\n", len(res.EmittedFiles))
-			for _, f := range res.EmittedFiles {
-				rel := f
-				if abs, err := filepath.Rel(cwd, f); err == nil {
-					rel = abs
-				}
-				fmt.Fprintln(stdout, "  +", rel)
-			}
-		}
-		if *manifestPath != "" {
-			// The manifest is intentionally just the emitted file list. Higher
-			// layers already know the project and tsconfig, and tests compare this
-			// array as the build contract.
-			data, _ := json.Marshal(res.EmittedFiles)
-			if err := os.MkdirAll(filepath.Dir(*manifestPath), 0o755); err != nil {
-				fmt.Fprintf(stderr, "ttsc: manifest mkdir failed: %v\n", err)
-				return 3
-			}
-			if err := os.WriteFile(*manifestPath, data, 0o644); err != nil {
-				fmt.Fprintf(stderr, "ttsc: manifest write failed: %v\n", err)
-				return 3
-			}
-		}
-	}
+  if shouldEmit {
+    // Emit is callback-driven in TypeScript-Go. ttsc keeps that shape and
+    // wraps only the final WriteFile step so native rewrites and custom output
+    // capture share the same path.
+    writeFile := shimcompiler.WriteFile(
+      func(fileName, text string, _ *shimcompiler.WriteFileData) error {
+        return driver.DefaultWriteFile(fileName, text)
+      },
+    )
+    res, eDiags, err := prog.EmitAll(rewrites, writeFile)
+    if err != nil {
+      fmt.Fprintf(stderr, "ttsc: emit failed: %v\n", err)
+      return 3
+    }
+    for _, d := range eDiags {
+      fmt.Fprintln(stderr, "  -", d.String())
+    }
+    if driver.CountErrors(eDiags) > 0 {
+      return 2
+    }
+    if !*quiet {
+      fmt.Fprintf(stdout, "// ttsc: emitted=%d files\n", len(res.EmittedFiles))
+      for _, f := range res.EmittedFiles {
+        rel := f
+        if abs, err := filepath.Rel(cwd, f); err == nil {
+          rel = abs
+        }
+        fmt.Fprintln(stdout, "  +", rel)
+      }
+    }
+    if *manifestPath != "" {
+      // The manifest is intentionally just the emitted file list. Higher
+      // layers already know the project and tsconfig, and tests compare this
+      // array as the build contract.
+      data, _ := json.Marshal(res.EmittedFiles)
+      if err := os.MkdirAll(filepath.Dir(*manifestPath), 0o755); err != nil {
+        fmt.Fprintf(stderr, "ttsc: manifest mkdir failed: %v\n", err)
+        return 3
+      }
+      if err := os.WriteFile(*manifestPath, data, 0o644); err != nil {
+        fmt.Fprintf(stderr, "ttsc: manifest write failed: %v\n", err)
+        return 3
+      }
+    }
+  }
 
-	if !*quiet {
-		fmt.Fprintf(stdout, "// ttsc: recognized=%d total=%d rewrites=%d\n", 0, 0, rewrites.Len())
-	}
-	return 0
+  if !*quiet {
+    fmt.Fprintf(stdout, "// ttsc: recognized=%d total=%d rewrites=%d\n", 0, 0, rewrites.Len())
+  }
+  return 0
 }

package/cmd/ttsc/build_branches_test.go

@@ -1,130 +1,128 @@
 package main
 
 import (
-	"errors"
-	"path/filepath"
-	"strings"
-	"testing"
+  "errors"
+  "path/filepath"
+  "strings"
+  "testing"
 
-	"github.com/samchon/ttsc/packages/ttsc/driver"
+  "github.com/samchon/ttsc/packages/ttsc/driver"
 )
 
 type buildApplyErrorPlugin struct{}
 
 func (buildApplyErrorPlugin) ApplyProgram(*driver.Program, driver.PluginContext) error {
-	return errors.New("build apply boom")
+  return errors.New("build apply boom")
 }
 
-/**
- * Verifies build command branches report setup, emit, and manifest failures.
- *
- * The native build command is the fallback compiler host behind ttsc. It must
- * fail before writing partial output when flags, cwd, tsconfig, disk emit, or
- * manifest paths are invalid.
- *
- * 1. Exercise bad flags, cwd failure, and project-load failures.
- * 2. Force emit through an invalid outDir.
- * 3. Force manifest mkdir and write failures after a valid emit.
- */
+// TestBuildBranches verifies build command branches report setup, emit, and manifest failures.
+//
+// The native build command is the fallback compiler host behind ttsc. It must
+// fail before writing partial output when flags, cwd, tsconfig, disk emit, or
+// manifest paths are invalid.
+//
+// 1. Exercise bad flags, cwd failure, and project-load failures.
+// 2. Force emit through an invalid outDir.
+// 3. Force manifest mkdir and write failures after a valid emit.
 func TestBuildBranches(t *testing.T) {
-	code, _, _ := captureCommand(t, func() int {
-		return runBuild([]string{"--cwd"})
-	})
-	if code != 2 {
-		t.Fatalf("bad flag status mismatch: %d", code)
-	}
-	code, _, errText := captureCommand(t, func() int {
-		getwd = failGetwd
-		return runBuild(nil)
-	})
-	if code != 2 || !strings.Contains(errText, "cwd boom") {
-		t.Fatalf("cwd error mismatch: code=%d stderr=%q", code, errText)
-	}
-	root := t.TempDir()
-	code, _, errText = captureCommand(t, func() int {
-		return runBuild([]string{"--cwd", root, "--tsconfig", "missing.json"})
-	})
-	if code != 2 || !strings.Contains(errText, "tsconfig not found") {
-		t.Fatalf("missing config mismatch: code=%d stderr=%q", code, errText)
-	}
+  code, _, _ := captureCommand(t, func() int {
+    return runBuild([]string{"--cwd"})
+  })
+  if code != 2 {
+    t.Fatalf("bad flag status mismatch: %d", code)
+  }
+  code, _, errText := captureCommand(t, func() int {
+    getwd = failGetwd
+    return runBuild(nil)
+  })
+  if code != 2 || !strings.Contains(errText, "cwd boom") {
+    t.Fatalf("cwd error mismatch: code=%d stderr=%q", code, errText)
+  }
+  root := t.TempDir()
+  code, _, errText = captureCommand(t, func() int {
+    return runBuild([]string{"--cwd", root, "--tsconfig", "missing.json"})
+  })
+  if code != 2 || !strings.Contains(errText, "tsconfig not found") {
+    t.Fatalf("missing config mismatch: code=%d stderr=%q", code, errText)
+  }
 
-	writeCommandProjectFile(t, root, "tsconfig.json", `{
+  writeCommandProjectFile(t, root, "tsconfig.json", `{
   "compilerOptions": { "module": "commonjs", "target": "es2020", "strict": true },
   "files": ["index.ts"]
 }
 `)
-	writeCommandProjectFile(t, root, "index.ts", `const value: number = "text";
+  writeCommandProjectFile(t, root, "index.ts", `const value: number = "text";
 export { value };
 `)
-	code, _, errText = captureCommand(t, func() int {
-		return runBuild([]string{"--cwd", root, "--tsconfig", "tsconfig.json"})
-	})
-	if code != 2 || !strings.Contains(errText, "number") {
-		t.Fatalf("semantic diagnostics mismatch: code=%d stderr=%q", code, errText)
-	}
+  code, _, errText = captureCommand(t, func() int {
+    return runBuild([]string{"--cwd", root, "--tsconfig", "tsconfig.json"})
+  })
+  if code != 2 || !strings.Contains(errText, "number") {
+    t.Fatalf("semantic diagnostics mismatch: code=%d stderr=%q", code, errText)
+  }
 
-	writeCommandProjectFile(t, root, "tsconfig.json", `{
+  writeCommandProjectFile(t, root, "tsconfig.json", `{
   "compilerOptions": { "module": "not-a-module-kind", "target": "es2020" },
   "files": ["index.ts"]
 }
 `)
-	code, _, errText = captureCommand(t, func() int {
-		return runBuild([]string{"--cwd", root, "--tsconfig", "tsconfig.json"})
-	})
-	if code != 2 || !strings.Contains(errText, "not-a-module-kind") {
-		t.Fatalf("invalid config mismatch: code=%d stderr=%q", code, errText)
-	}
+  code, _, errText = captureCommand(t, func() int {
+    return runBuild([]string{"--cwd", root, "--tsconfig", "tsconfig.json"})
+  })
+  if code != 2 || !strings.Contains(errText, "not-a-module-kind") {
+    t.Fatalf("invalid config mismatch: code=%d stderr=%q", code, errText)
+  }
 
-	writeCommandProjectFile(t, root, "tsconfig.json", `{
+  writeCommandProjectFile(t, root, "tsconfig.json", `{
   "compilerOptions": { "module": "commonjs", "target": "es2020", "strict": true },
   "files": ["index.ts"]
 }
 `)
-	writeCommandProjectFile(t, root, "index.ts", `export const value = 1;
+  writeCommandProjectFile(t, root, "index.ts", `export const value = 1;
 `)
-	writeCommandProjectFile(t, root, "blocked", `not a directory`)
-	code, _, errText = captureCommand(t, func() int {
-		return runBuild([]string{"--cwd", root, "--tsconfig", "tsconfig.json", "--emit", "--outDir", "blocked"})
-	})
-	if code != 2 || !strings.Contains(errText, "not a directory") {
-		t.Fatalf("emit failure mismatch: code=%d stderr=%q", code, errText)
-	}
+  writeCommandProjectFile(t, root, "blocked", `not a directory`)
+  code, _, errText = captureCommand(t, func() int {
+    return runBuild([]string{"--cwd", root, "--tsconfig", "tsconfig.json", "--emit", "--outDir", "blocked"})
+  })
+  if code != 2 || !strings.Contains(errText, "not a directory") {
+    t.Fatalf("emit failure mismatch: code=%d stderr=%q", code, errText)
+  }
 
-	resetCommandLinkedPluginRegistry()
-	driver.RegisterPlugin(buildApplyErrorPlugin{})
-	t.Cleanup(resetCommandLinkedPluginRegistry)
-	t.Setenv(driver.LinkedPluginsEnv, `[{"name":"error","stage":"transform","config":{}}]`)
-	code, _, errText = captureCommand(t, func() int {
-		return runBuild([]string{"--cwd", root, "--tsconfig", "tsconfig.json", "--emit", "--outDir", "dist"})
-	})
-	if code != 3 || !strings.Contains(errText, "build apply boom") {
-		t.Fatalf("linked apply failure mismatch: code=%d stderr=%q", code, errText)
-	}
-	resetCommandLinkedPluginRegistry()
-	t.Setenv(driver.LinkedPluginsEnv, "")
+  resetCommandLinkedPluginRegistry()
+  driver.RegisterPlugin(buildApplyErrorPlugin{})
+  t.Cleanup(resetCommandLinkedPluginRegistry)
+  t.Setenv(driver.LinkedPluginsEnv, `[{"name":"error","stage":"transform","config":{}}]`)
+  code, _, errText = captureCommand(t, func() int {
+    return runBuild([]string{"--cwd", root, "--tsconfig", "tsconfig.json", "--emit", "--outDir", "dist"})
+  })
+  if code != 3 || !strings.Contains(errText, "build apply boom") {
+    t.Fatalf("linked apply failure mismatch: code=%d stderr=%q", code, errText)
+  }
+  resetCommandLinkedPluginRegistry()
+  t.Setenv(driver.LinkedPluginsEnv, "")
 
-	code, _, errText = captureCommand(t, func() int {
-		return runBuild([]string{
-			"--cwd", root,
-			"--tsconfig", "tsconfig.json",
-			"--emit",
-			"--outDir", "dist",
-			"--manifest", filepath.Join(root, "index.ts", "manifest.json"),
-		})
-	})
-	if code != 3 || !strings.Contains(errText, "manifest mkdir failed") {
-		t.Fatalf("manifest mkdir mismatch: code=%d stderr=%q", code, errText)
-	}
-	code, _, errText = captureCommand(t, func() int {
-		return runBuild([]string{
-			"--cwd", root,
-			"--tsconfig", "tsconfig.json",
-			"--emit",
-			"--outDir", "dist",
-			"--manifest", root,
-		})
-	})
-	if code != 3 || !strings.Contains(errText, "manifest write failed") {
-		t.Fatalf("manifest write mismatch: code=%d stderr=%q", code, errText)
-	}
+  code, _, errText = captureCommand(t, func() int {
+    return runBuild([]string{
+      "--cwd", root,
+      "--tsconfig", "tsconfig.json",
+      "--emit",
+      "--outDir", "dist",
+      "--manifest", filepath.Join(root, "index.ts", "manifest.json"),
+    })
+  })
+  if code != 3 || !strings.Contains(errText, "manifest mkdir failed") {
+    t.Fatalf("manifest mkdir mismatch: code=%d stderr=%q", code, errText)
+  }
+  code, _, errText = captureCommand(t, func() int {
+    return runBuild([]string{
+      "--cwd", root,
+      "--tsconfig", "tsconfig.json",
+      "--emit",
+      "--outDir", "dist",
+      "--manifest", root,
+    })
+  })
+  if code != 3 || !strings.Contains(errText, "manifest write failed") {
+    t.Fatalf("manifest write mismatch: code=%d stderr=%q", code, errText)
+  }
 }

package/cmd/ttsc/helpers_test.go

@@ -1,47 +1,58 @@
 package main
 
 import (
-	"bytes"
-	"errors"
-	"os"
-	"path/filepath"
-	"testing"
-	_ "unsafe"
+  "bytes"
+  "errors"
+  "os"
+  "path/filepath"
+  "testing"
+  _ "unsafe"
 )
 
+// driverPluginRegistry is a linkname alias for the unexported plugin slice in
+// the driver package, allowing tests to reset registered plugins between cases.
+//
 //go:linkname driverPluginRegistry github.com/samchon/ttsc/packages/ttsc/driver.pluginRegistry
 var driverPluginRegistry []any
 
+// captureCommand redirects the package-level stdout/stderr/getwd seams around
+// fn, then returns the exit code and the captured output strings.
 func captureCommand(t *testing.T, fn func() int) (int, string, string) {
-	t.Helper()
-	prevOut, prevErr, prevGetwd := stdout, stderr, getwd
-	var out, err bytes.Buffer
-	stdout = &out
-	stderr = &err
-	defer func() {
-		stdout = prevOut
-		stderr = prevErr
-		getwd = prevGetwd
-	}()
-	code := fn()
-	return code, out.String(), err.String()
+  t.Helper()
+  prevOut, prevErr, prevGetwd := stdout, stderr, getwd
+  var out, err bytes.Buffer
+  stdout = &out
+  stderr = &err
+  defer func() {
+    stdout = prevOut
+    stderr = prevErr
+    getwd = prevGetwd
+  }()
+  code := fn()
+  return code, out.String(), err.String()
 }
 
+// failGetwd is a getwd stub that always returns an error, used to exercise the
+// cwd-resolution failure path in command entrypoints.
 func failGetwd() (string, error) {
-	return "", errors.New("cwd boom")
+  return "", errors.New("cwd boom")
 }
 
+// writeCommandProjectFile writes contents to root/name, creating intermediate
+// directories as needed. Slashes in name are normalised to the OS separator.
 func writeCommandProjectFile(t *testing.T, root, name, contents string) {
-	t.Helper()
-	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(contents), 0o644); err != nil {
-		t.Fatal(err)
-	}
+  t.Helper()
+  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(contents), 0o644); err != nil {
+    t.Fatal(err)
+  }
 }
 
+// resetCommandLinkedPluginRegistry clears the driver plugin registry so that
+// tests that register plugins do not pollute subsequent test cases.
 func resetCommandLinkedPluginRegistry() {
-	driverPluginRegistry = nil
+  driverPluginRegistry = nil
 }