ttsc 0.3.0 → 0.4.0-dev.20260424

package/cmd/ttsc/build.go

@@ -0,0 +1,128 @@
+package main
+
+import (
+	"encoding/json"
+	"flag"
+	"fmt"
+	"os"
+	"path/filepath"
+
+	shimcompiler "github.com/microsoft/typescript-go/shim/compiler"
+
+	"github.com/samchon/ttsc/packages/ttsc/driver"
+)
+
+// runBuild implements the `ttsc` project-build lane. Two modes:
+//
+//   - default (dry run): analyze quietly, surfacing only diagnostics/errors.
+//   - --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")
+	rewriteMode := fs.String("rewrite-mode", "none", "native rewrite backend id")
+	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
+		}
+	}
+
+	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 *rewriteMode != "none" {
+		fmt.Fprintf(stderr, "ttsc: rewrite backend %q is not built into the standalone ttsc binary\n", *rewriteMode)
+		fmt.Fprintln(stderr, "ttsc: run through the JS host with the matching compiler plugin so it can select the consumer-provided native binary")
+		return 2
+	}
+	if !*quiet {
+		fmt.Fprintf(stdout, "// ttsc: tsconfig=%s cwd=%s sites=%d emit=%v rewrite=%s\n", *tsconfigPath, cwd, 0, shouldEmit, *rewriteMode)
+	}
+
+	if shouldEmit {
+		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 != "" {
+			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 !*quiet {
+		fmt.Fprintf(stdout, "// ttsc: recognized=%d total=%d rewrites=%d\n", 0, 0, rewrites.Len())
+	}
+	return 0
+}

package/cmd/ttsc/main.go

@@ -0,0 +1,222 @@
+// Command ttsc is the Go CLI entrypoint for ttsc.
+//
+// Current responsibilities:
+//   - Report version and platform (`ttsc --version`).
+//   - Exercise a native rewrite backend end-to-end (`ttsc demo --type=string`)
+//     so smoke tests can verify the Go binary really runs.
+//   - Act as a placeholder for the eventual `build` / `dev` / `check` / `setup`
+//     subcommands that will land in Week 3+.
+//
+// Everything below is deliberately dependency-free so that the standalone binary
+// stays small and its behavior is trivial to audit.
+package main
+
+import (
+	"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"
+)
+
+// stdout / stderr are package-level to keep the CLI testable.
+var (
+	stdout io.Writer = os.Stdout
+	stderr io.Writer = os.Stderr
+)
+
+func main() {
+	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 "check":
+		// `ttsc check` runs the analyze pipeline without emitting JS — useful
+		// in CI and pre-commit hooks that only need schema validation.
+		return runBuild(append([]string{"--noEmit"}, args[1:]...))
+	case "transform":
+		// Single-file transform for bundler plugin integration (unplugin,
+		// vite, esbuild, webpack, …). Emits only the requested file's JS to
+		// stdout or a chosen path — no project-wide write.
+		return runTransform(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
+	}
+}
+
+// appendUnique appends `extra` to `args` only when it's not already present.
+func appendUnique(args []string, extra ...string) []string {
+	out := append([]string{}, args...)
+	for _, e := range extra {
+		seen := false
+		for _, a := range out {
+			if a == e {
+				seen = true
+				break
+			}
+		}
+		if !seen {
+			out = append(out, e)
+		}
+	}
+	return out
+}
+
+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(),
+	)
+}
+
+func printHelp(w io.Writer) {
+	fmt.Fprintln(w, strings.TrimSpace(`
+ttsc — standalone typescript-go host.
+
+Usage:
+  ttsc
+  ttsc -p tsconfig.json
+  ttsc --watch
+  ttsc --noEmit
+  ttsc transform --file=src/main.ts
+
+Project build:
+  ttsc compiles the current tsconfig.json, matching the tsc/tsgo shape.
+  build         Compatibility alias for the same project build lane.
+  check         Compatibility alias for --noEmit validation.
+  transform     Emit a single file's rewritten JS (bundler plugin hook).
+  demo          Run a native backend smoke pipeline with synthetic input.
+  version       Print version, build info, and platform.
+  help          Show this help.
+
+Build options:
+  --tsconfig=FILE   Path to tsconfig.json (default: tsconfig.json).
+  --cwd=DIR         Override working directory.
+  --emit            Force emitted .js files even when tsconfig has noEmit.
+  --noEmit          Force analysis-only run even when tsconfig would emit.
+  --quiet           Suppress the per-call summary banner (default).
+  --verbose         Print the per-call summary banner and emitted file list.
+  --rewrite-mode=M  Native rewrite backend id.
+  --manifest=FILE   Write emitted file paths as JSON to FILE after build --emit.
+
+Transform options:
+  --file=PATH       Absolute or cwd-relative path of the .ts file to transform.
+  --tsconfig=FILE   tsconfig.json owning --file (default: tsconfig.json).
+  --out=PATH        Write output JS to PATH. Default: stdout.
+  --rewrite-mode=M  Native rewrite backend id.
+
+Demo options:
+  --type=T          Atomic TypeScript type to simulate. One of:
+                      string, number, boolean, bigint, any (default: string).
+
+Examples:
+  ttsc --version
+  ttsc
+  ttsc -p ./tsconfig.json
+  ttsc --noEmit
+  ttsc transform --file=src/main.ts
+  ttsc demo --type=number
+
+Integration guide (bundlers):
+  - vite / webpack / rollup / esbuild: shell out to "ttsc transform" per file,
+    forward stdout as the bundler transform result. A bundler adapter can wrap
+    this command without depending on the Go internals.
+  - Next.js / Nuxt / Bun: "ttsc" in your pipeline replaces tsc and
+    the rewritten .js feeds the runtime directly.
+  - Monorepo / pnpm workspace: share one ttsc binary via a root script;
+    per-package tsconfig.json references work unchanged.
+`))
+}
+
+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
+}
+
+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)
+	}
+}

package/cmd/ttsc/main_test.go

@@ -0,0 +1,288 @@
+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)
+			}
+		})
+	}
+}