ttsc 0.11.0 → 0.12.0

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,111 +25,110 @@ 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 = os.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 := !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 !*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, err := json.Marshal(res.EmittedFiles)
-      if err != nil {
-        fmt.Fprintf(stderr, "ttsc: manifest marshal failed: %v\n", err)
-        return 3
-      }
-      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

@@ -0,0 +1,130 @@
+package main
+
+import (
+	"errors"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/samchon/ttsc/packages/ttsc/driver"
+)
+
+type buildApplyErrorPlugin struct{}
+
+func (buildApplyErrorPlugin) ApplyProgram(*driver.Program, driver.PluginContext) error {
+	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.
+ */
+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)
+	}
+
+	writeCommandProjectFile(t, root, "tsconfig.json", `{
+  "compilerOptions": { "module": "commonjs", "target": "es2020", "strict": true },
+  "files": ["index.ts"]
+}
+`)
+	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)
+	}
+
+	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)
+	}
+
+	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, "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, "")
+
+	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

@@ -0,0 +1,47 @@
+package main
+
+import (
+	"bytes"
+	"errors"
+	"os"
+	"path/filepath"
+	"testing"
+	_ "unsafe"
+)
+
+//go:linkname driverPluginRegistry github.com/samchon/ttsc/packages/ttsc/driver.pluginRegistry
+var driverPluginRegistry []any
+
+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()
+}
+
+func failGetwd() (string, error) {
+	return "", errors.New("cwd boom")
+}
+
+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)
+	}
+}
+
+func resetCommandLinkedPluginRegistry() {
+	driverPluginRegistry = nil
+}

package/cmd/ttsc/main.go

@@ -12,103 +12,104 @@
 package main
 
 import (
-  "flag"
-  "fmt"
-  "io"
-  "os"
-  "runtime"
-  "strings"
+	"flag"
+	"fmt"
+	"io"
+	"os"
+	"runtime"
+	"strings"
 )
 
 // These are overridden via `-ldflags "-X main.version=... -X main.commit=..."`
 // in CI. Sensible defaults keep local `go run ./cmd/ttsc` usable.
 var (
-  version = "0.0.0-dev"
-  commit  = "dev"
-  date    = "unknown"
+	version = "0.0.0-dev"
+	commit  = "dev"
+	date    = "unknown"
 )
 
 // stdout / stderr are package-level to keep the CLI testable.
 var (
-  stdout io.Writer = os.Stdout
-  stderr io.Writer = os.Stderr
+	stdout io.Writer = os.Stdout
+	stderr io.Writer = os.Stderr
+	getwd            = os.Getwd
 )
 
 func main() {
-  os.Exit(run(os.Args[1:]))
+	os.Exit(run(os.Args[1:]))
 }
 
 func run(args []string) int {
-  if len(args) == 0 {
-    return runBuild(nil)
-  }
-
-  switch args[0] {
-  case "-h", "--help", "help":
-    printHelp(stdout)
-    return 0
-  case "-v", "--version", "version":
-    printVersion(stdout)
-    return 0
-  case "demo":
-    return runDemo(args[1:])
-  case "build":
-    return runBuild(args[1:])
-  case "api-compile":
-    return runAPICompile(args[1:])
-  case "api-transform":
-    return runAPITransform(args[1:])
-  case "check":
-    // `ttsc check` runs the analyze pipeline without emitting JS — useful
-    // in CI and pre-commit checks that only need schema validation.
-    return runBuild(append([]string{"--noEmit"}, args[1:]...))
-  case "-p", "--project":
-    if len(args) < 2 {
-      fmt.Fprintln(stderr, "ttsc: -p/--project requires a path argument")
-      return 2
-    }
-    return runBuild(append([]string{"--tsconfig=" + args[1]}, args[2:]...))
-  default:
-    if isBuildAlias(args[0]) {
-      return runBuild(args)
-    }
-    fmt.Fprintf(stderr, "ttsc: unknown command %q\n", args[0])
-    fmt.Fprintln(stderr, `ttsc: run "ttsc --help" to see supported commands`)
-    return 2
-  }
+	if len(args) == 0 {
+		return runBuild(nil)
+	}
+
+	switch args[0] {
+	case "-h", "--help", "help":
+		printHelp(stdout)
+		return 0
+	case "-v", "--version", "version":
+		printVersion(stdout)
+		return 0
+	case "demo":
+		return runDemo(args[1:])
+	case "build":
+		return runBuild(args[1:])
+	case "api-compile":
+		return runAPICompile(args[1:])
+	case "api-transform":
+		return runAPITransform(args[1:])
+	case "check":
+		// `ttsc check` runs the analyze pipeline without emitting JS — useful
+		// in CI and pre-commit checks that only need schema validation.
+		return runBuild(append([]string{"--noEmit"}, args[1:]...))
+	case "-p", "--project":
+		if len(args) < 2 {
+			fmt.Fprintln(stderr, "ttsc: -p/--project requires a path argument")
+			return 2
+		}
+		return runBuild(append([]string{"--tsconfig=" + args[1]}, args[2:]...))
+	default:
+		if isBuildAlias(args[0]) {
+			return runBuild(args)
+		}
+		fmt.Fprintf(stderr, "ttsc: unknown command %q\n", args[0])
+		fmt.Fprintln(stderr, `ttsc: run "ttsc --help" to see supported commands`)
+		return 2
+	}
 }
 
 func isBuildAlias(arg string) bool {
-  if strings.HasPrefix(arg, "-") {
-    return true
-  }
-  switch {
-  case strings.HasSuffix(arg, ".json"),
-    strings.HasSuffix(arg, ".ts"),
-    strings.HasSuffix(arg, ".tsx"),
-    strings.HasSuffix(arg, ".mts"),
-    strings.HasSuffix(arg, ".cts"):
-    return true
-  default:
-    return false
-  }
+	if strings.HasPrefix(arg, "-") {
+		return true
+	}
+	switch {
+	case strings.HasSuffix(arg, ".json"),
+		strings.HasSuffix(arg, ".ts"),
+		strings.HasSuffix(arg, ".tsx"),
+		strings.HasSuffix(arg, ".mts"),
+		strings.HasSuffix(arg, ".cts"):
+		return true
+	default:
+		return false
+	}
 }
 
 func printVersion(w io.Writer) {
-  fmt.Fprintf(
-    w,
-    "ttsc %s (commit %s, built %s, %s/%s, go %s)\n",
-    version,
-    commit,
-    date,
-    runtime.GOOS,
-    runtime.GOARCH,
-    runtime.Version(),
-  )
+	fmt.Fprintf(
+		w,
+		"ttsc %s (commit %s, built %s, %s/%s, go %s)\n",
+		version,
+		commit,
+		date,
+		runtime.GOOS,
+		runtime.GOARCH,
+		runtime.Version(),
+	)
 }
 
 func printHelp(w io.Writer) {
-  fmt.Fprintln(w, strings.TrimSpace(`
+	fmt.Fprintln(w, strings.TrimSpace(`
 ttsc — standalone typescript-go host.
 
 Usage:
@@ -154,37 +155,37 @@ Integration guide (bundlers):
 }
 
 func runDemo(args []string) int {
-  fs := flag.NewFlagSet("demo", flag.ContinueOnError)
-  fs.SetOutput(stderr)
-  typ := fs.String("type", "string", "atomic type to simulate")
-  if err := fs.Parse(args); err != nil {
-    return 2
-  }
-
-  arrow, err := demoArrow(*typ)
-  if err != nil {
-    fmt.Fprintf(stderr, "ttsc demo: %v\n", err)
-    return 2
-  }
-
-  fmt.Fprintf(stdout, "// demo<%s> -> emitted by ttsc %s\n", *typ, version)
-  fmt.Fprintln(stdout, arrow)
-  return 0
+	fs := flag.NewFlagSet("demo", flag.ContinueOnError)
+	fs.SetOutput(stderr)
+	typ := fs.String("type", "string", "atomic type to simulate")
+	if err := fs.Parse(args); err != nil {
+		return 2
+	}
+
+	arrow, err := demoArrow(*typ)
+	if err != nil {
+		fmt.Fprintf(stderr, "ttsc demo: %v\n", err)
+		return 2
+	}
+
+	fmt.Fprintf(stdout, "// demo<%s> -> emitted by ttsc %s\n", *typ, version)
+	fmt.Fprintln(stdout, arrow)
+	return 0
 }
 
 func demoArrow(name string) (string, error) {
-  switch strings.ToLower(name) {
-  case "any":
-    return "(input) => true", nil
-  case "boolean":
-    return `(input) => "boolean" === typeof input`, nil
-  case "number":
-    return `(input) => "number" === typeof input`, nil
-  case "bigint":
-    return `(input) => "bigint" === typeof input`, nil
-  case "string", "":
-    return `(input) => "string" === typeof input`, nil
-  default:
-    return "", fmt.Errorf("unknown --type value %q (want: string|number|boolean|bigint|any)", name)
-  }
+	switch strings.ToLower(name) {
+	case "any":
+		return "(input) => true", nil
+	case "boolean":
+		return `(input) => "boolean" === typeof input`, nil
+	case "number":
+		return `(input) => "number" === typeof input`, nil
+	case "bigint":
+		return `(input) => "bigint" === typeof input`, nil
+	case "string", "":
+		return `(input) => "string" === typeof input`, nil
+	default:
+		return "", fmt.Errorf("unknown --type value %q (want: string|number|boolean|bigint|any)", name)
+	}
 }