ttsc 0.3.0 → 0.4.0-dev.20260424

package/driver/rewrite.go

@@ -0,0 +1,315 @@
+// Package driver: post-emit rewriter.
+//
+// tsgo emits `.js` with plugin-owned call expressions preserved as-is because
+// the compile-time transformer stage is now hosted outside the native
+// compiler. This file implements the emit-time rewrite pattern pioneered by
+// tsgonest: we hook tsgo's Emit() via its WriteFile callback, locate each
+// previously-recognized plugin call in the emitted JS, and replace the call
+// expression with the JS the native consumer produced.
+//
+// The rewriter operates on the output text only — it relies on the caller
+// having already produced an ordered list of (file, call, emittedJS) triples.
+// Today we match by textual pattern (`<alias>.<method>(...)`), which is safe
+// because the compiler-stripped call site is distinctive.
+package driver
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+	"unicode"
+
+	"github.com/microsoft/typescript-go/shim/ast"
+	shimcompiler "github.com/microsoft/typescript-go/shim/compiler"
+)
+
+// Rewrite describes one emit-time patch. Produced by CollectCallSites after
+// the engine has generated a replacement JS fragment for the call.
+type Rewrite struct {
+	File          *ast.SourceFile
+	RootName      string
+	Namespaces    []string
+	Method        string
+	Replacement   string
+	ConsumeParens bool
+}
+
+// RewriteSet groups rewrites by file, preserving source order.
+type RewriteSet struct {
+	byPath map[string][]Rewrite
+}
+
+// NewRewriteSet returns an empty set.
+func NewRewriteSet() *RewriteSet { return &RewriteSet{byPath: map[string][]Rewrite{}} }
+
+// Add registers a rewrite under the absolute path of its source file.
+func (rs *RewriteSet) Add(r Rewrite) {
+	if r.File == nil {
+		return
+	}
+	path := filepath.ToSlash(r.File.FileName())
+	rs.byPath[path] = append(rs.byPath[path], r)
+}
+
+// Len returns the total number of rewrites across every file.
+func (rs *RewriteSet) Len() int {
+	n := 0
+	for _, rws := range rs.byPath {
+		n += len(rws)
+	}
+	return n
+}
+
+// RewriteSentinel is the marker inserted at the top of a patched file so
+// re-running the emit on an already-rewritten file is a no-op.
+const RewriteSentinel = "/* @ttsc-rewritten */"
+
+// EmitAll runs tsgo's emitter, patching every registered plugin-owned call in
+// the output. Returns the tsgo diagnostics and any patch-time error. When
+// `writeFile` is nil, the patched JS is written to disk via the standard
+// tsgo WriteFile.
+func (p *Program) EmitAll(rs *RewriteSet, writeFile shimcompiler.WriteFile) (*shimcompiler.EmitResult, []Diagnostic, error) {
+	return p.emit(rs, nil, writeFile)
+}
+
+// EmitFile runs tsgo's emitter for one source file, applying the same rewrite
+// pipeline as EmitAll.
+func (p *Program) EmitFile(rs *RewriteSet, target *ast.SourceFile, writeFile shimcompiler.WriteFile) (*shimcompiler.EmitResult, []Diagnostic, error) {
+	return p.emit(rs, target, writeFile)
+}
+
+func (p *Program) emit(rs *RewriteSet, target *ast.SourceFile, writeFile shimcompiler.WriteFile) (*shimcompiler.EmitResult, []Diagnostic, error) {
+	if p == nil || p.TSProgram == nil {
+		return nil, nil, errors.New("driver: nil program")
+	}
+	if rs == nil {
+		rs = NewRewriteSet()
+	}
+	cursors := map[string]int{}
+	wf := func(fileName, text string, data *shimcompiler.WriteFileData) error {
+		if strings.Contains(text, RewriteSentinel) {
+			if writeFile != nil {
+				return writeFile(fileName, text, data)
+			}
+			return DefaultWriteFile(fileName, text)
+		}
+		patched, err := applyRewrites(fileName, text, rs, cursors)
+		if err != nil {
+			return err
+		}
+		if patched != text {
+			patched = insertSentinel(patched)
+		}
+		if writeFile != nil {
+			return writeFile(fileName, patched, data)
+		}
+		return DefaultWriteFile(fileName, patched)
+	}
+
+	result := p.TSProgram.Emit(context.Background(), shimcompiler.EmitOptions{
+		TargetSourceFile: target,
+		WriteFile:        wf,
+	})
+	if result == nil {
+		return nil, nil, errors.New("driver: Emit returned nil")
+	}
+	return result, convertDiagnostics(result.Diagnostics), nil
+}
+
+// DefaultWriteFile is the default disk writer used when EmitAll's caller does not
+// supply a custom WriteFile hook.
+func DefaultWriteFile(fileName, text string) error {
+	if dir := filepath.Dir(fileName); dir != "" {
+		if err := os.MkdirAll(dir, 0o755); err != nil {
+			return err
+		}
+	}
+	return os.WriteFile(fileName, []byte(text), 0o644)
+}
+
+func insertSentinel(text string) string {
+	for _, prefix := range []string{"\"use strict\";\n", "'use strict';\n"} {
+		if strings.HasPrefix(text, prefix) {
+			return prefix + RewriteSentinel + "\n" + text[len(prefix):]
+		}
+	}
+	return RewriteSentinel + "\n" + text
+}
+
+func applyRewrites(outputName, text string, rs *RewriteSet, cursors map[string]int) (string, error) {
+	srcPath, ok := findSourceForOutput(outputName, rs)
+	if !ok || len(rs.byPath[srcPath]) == 0 {
+		return text, nil
+	}
+	rewrites := rs.byPath[srcPath]
+	pos := cursors[srcPath]
+	out := text
+	searchFrom := 0
+	for pos < len(rewrites) {
+		r := rewrites[pos]
+		replaced, nextSearchFrom, ok, err := spliceCall(out, r, searchFrom)
+		if err != nil {
+			return "", err
+		}
+		if !ok {
+			preview := out
+			if len(preview) > 400 {
+				preview = preview[:400] + "…"
+			}
+			return "", fmt.Errorf("driver: could not locate %s.%s(…) call in %s (tried roots %v; preview: %q)", joinRootAndNamespaces(r), r.Method, outputName, candidateRoots(r.RootName), preview)
+		}
+		out = replaced
+		searchFrom = nextSearchFrom
+		pos++
+	}
+	cursors[srcPath] = pos
+	return out, nil
+}
+
+func findSourceForOutput(outputName string, rs *RewriteSet) (string, bool) {
+	outSlash := strings.TrimSuffix(filepath.ToSlash(outputName), filepath.Ext(outputName))
+	var best string
+	bestScore := 0
+	for path := range rs.byPath {
+		srcStem := strings.TrimSuffix(filepath.ToSlash(path), filepath.Ext(path))
+		score := commonSuffixSegments(srcStem, outSlash)
+		if score > bestScore {
+			best = path
+			bestScore = score
+		}
+	}
+	return best, bestScore > 0
+}
+
+func commonSuffixSegments(a, b string) int {
+	as := strings.Split(a, "/")
+	bs := strings.Split(b, "/")
+	n := len(as)
+	if len(bs) < n {
+		n = len(bs)
+	}
+	shared := 0
+	for i := 1; i <= n; i++ {
+		if as[len(as)-i] != bs[len(bs)-i] {
+			break
+		}
+		shared++
+	}
+	return shared
+}
+
+func spliceCall(text string, r Rewrite, searchFrom int) (string, int, bool, error) {
+	aliases := candidateRoots(r.RootName)
+	tail := needleTail(r)
+	idx := -1
+	needleLen := 0
+	for _, cand := range aliases {
+		candNeedle := cand + tail
+		if i := indexAtCallStart(text, candNeedle, searchFrom); i >= 0 {
+			idx = i
+			needleLen = len(candNeedle) - 1
+			break
+		}
+	}
+	if idx < 0 {
+		return text, searchFrom, false, nil
+	}
+	parenPos := idx + needleLen
+	if parenPos >= len(text) || text[parenPos] != '(' {
+		return text, searchFrom, false, errors.New("driver: expected '(' after method name")
+	}
+	closePos, ok := matchParen(text, parenPos)
+	if !ok {
+		return text, searchFrom, false, errors.New("driver: unbalanced parens while locating plugin call")
+	}
+	if r.ConsumeParens {
+		replaced := text[:idx] + r.Replacement + text[closePos+1:]
+		return replaced, idx + len(r.Replacement), true, nil
+	}
+	replaced := text[:idx] + r.Replacement + text[idx+needleLen:]
+	return replaced, idx + len(r.Replacement), true, nil
+}
+
+func candidateRoots(root string) []string {
+	return []string{
+		root,
+		root + "_1.default",
+		root + "_2.default",
+		root + ".default",
+		root + "_1",
+		root + "_2",
+	}
+}
+
+func joinRootAndNamespaces(r Rewrite) string {
+	if len(r.Namespaces) == 0 {
+		return r.RootName
+	}
+	return r.RootName + "." + strings.Join(r.Namespaces, ".")
+}
+
+func needleTail(r Rewrite) string {
+	if len(r.Namespaces) == 0 {
+		return "." + r.Method + "("
+	}
+	return "." + strings.Join(r.Namespaces, ".") + "." + r.Method + "("
+}
+
+func indexAtCallStart(text, needle string, searchFrom int) int {
+	start := searchFrom
+	if start < 0 {
+		start = 0
+	}
+	for {
+		hit := strings.Index(text[start:], needle)
+		if hit < 0 {
+			return -1
+		}
+		pos := start + hit
+		if pos == 0 {
+			return pos
+		}
+		prev := rune(text[pos-1])
+		if isIdentifierPart(prev) {
+			start = pos + 1
+			continue
+		}
+		return pos
+	}
+}
+
+func isIdentifierPart(r rune) bool {
+	return r == '_' || r == '$' || unicode.IsLetter(r) || unicode.IsDigit(r)
+}
+
+func matchParen(text string, pos int) (int, bool) {
+	if pos >= len(text) || text[pos] != '(' {
+		return 0, false
+	}
+	depth := 1
+	for i := pos + 1; i < len(text); i++ {
+		switch text[i] {
+		case '(':
+			depth++
+		case ')':
+			depth--
+			if depth == 0 {
+				return i, true
+			}
+		case '"', '\'', '`':
+			q := text[i]
+			j := i + 1
+			for j < len(text) && text[j] != q {
+				if text[j] == '\\' {
+					j++
+				}
+				j++
+			}
+			i = j
+		}
+	}
+	return 0, false
+}

package/go.mod

@@ -0,0 +1,48 @@
+module github.com/samchon/ttsc/packages/ttsc
+
+go 1.26
+
+// Every shim sub-module is wired up via the sibling go.work file together
+// with the local typescript-go checkout under ../../third_party/typescript-go.
+// Tagged upstream versions can replace these local wires when the shim API
+// stabilizes.
+replace (
+	github.com/microsoft/typescript-go/shim/ast => ./shim/ast
+	github.com/microsoft/typescript-go/shim/bundled => ./shim/bundled
+	github.com/microsoft/typescript-go/shim/checker => ./shim/checker
+	github.com/microsoft/typescript-go/shim/compiler => ./shim/compiler
+	github.com/microsoft/typescript-go/shim/core => ./shim/core
+	github.com/microsoft/typescript-go/shim/diagnosticwriter => ./shim/diagnosticwriter
+	github.com/microsoft/typescript-go/shim/parser => ./shim/parser
+	github.com/microsoft/typescript-go/shim/scanner => ./shim/scanner
+	github.com/microsoft/typescript-go/shim/tsoptions => ./shim/tsoptions
+	github.com/microsoft/typescript-go/shim/tspath => ./shim/tspath
+	github.com/microsoft/typescript-go/shim/vfs => ./shim/vfs
+	github.com/microsoft/typescript-go/shim/vfs/cachedvfs => ./shim/vfs/cachedvfs
+	github.com/microsoft/typescript-go/shim/vfs/osvfs => ./shim/vfs/osvfs
+)
+
+require (
+	github.com/microsoft/typescript-go/shim/ast v0.0.0
+	github.com/microsoft/typescript-go/shim/bundled v0.0.0
+	github.com/microsoft/typescript-go/shim/checker v0.0.0
+	github.com/microsoft/typescript-go/shim/compiler v0.0.0
+	github.com/microsoft/typescript-go/shim/core v0.0.0
+	github.com/microsoft/typescript-go/shim/diagnosticwriter v0.0.0
+	github.com/microsoft/typescript-go/shim/scanner v0.0.0
+	github.com/microsoft/typescript-go/shim/tsoptions v0.0.0
+	github.com/microsoft/typescript-go/shim/tspath v0.0.0
+	github.com/microsoft/typescript-go/shim/vfs v0.0.0
+	github.com/microsoft/typescript-go/shim/vfs/cachedvfs v0.0.0
+	github.com/microsoft/typescript-go/shim/vfs/osvfs v0.0.0
+)
+
+require (
+	github.com/go-json-experiment/json v0.0.0-20260214004413-d219187c3433 // indirect
+	github.com/klauspost/cpuid/v2 v2.2.10 // indirect
+	github.com/microsoft/typescript-go v0.0.0-20260408193441-2a5e1cf9fe22 // indirect
+	github.com/zeebo/xxh3 v1.1.0 // indirect
+	golang.org/x/sync v0.20.0 // indirect
+	golang.org/x/sys v0.42.0 // indirect
+	golang.org/x/text v0.35.0 // indirect
+)

package/go.sum

@@ -0,0 +1,22 @@
+github.com/go-json-experiment/json v0.0.0-20260214004413-d219187c3433 h1:vymEbVwYFP/L05h5TKQxvkXoKxNvTpjxYKdF1Nlwuao=
+github.com/go-json-experiment/json v0.0.0-20260214004413-d219187c3433/go.mod h1:tphK2c80bpPhMOI4v6bIc2xWywPfbqi1Z06+RcrMkDg=
+github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
+github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
+github.com/klauspost/cpuid/v2 v2.2.10 h1:tBs3QSyvjDyFTq3uoc/9xFpCuOsJQFNPiAhYdw2skhE=
+github.com/klauspost/cpuid/v2 v2.2.10/go.mod h1:hqwkgyIinND0mEev00jJYCxPNVRVXFQeu1XKlok6oO0=
+github.com/microsoft/typescript-go v0.0.0-20260408193441-2a5e1cf9fe22 h1:iH0TuqCh+yQ95Ea0f9lVM5B1xkTqlmxQhzOEj8QWR6o=
+github.com/microsoft/typescript-go v0.0.0-20260408193441-2a5e1cf9fe22/go.mod h1:eE2mO7PBRpeR8gWgxwsZq1LOW4tsgIF6zd0iQ5TbsJU=
+github.com/peter-evans/patience v0.3.0 h1:rX0JdJeepqdQl1Sk9c9uvorjYYzL2TfgLX1adqYm9cA=
+github.com/peter-evans/patience v0.3.0/go.mod h1:Kmxu5sY1NmBLFSStvXjX1wS9mIv7wMcP/ubucyMOAu0=
+github.com/zeebo/assert v1.3.0 h1:g7C04CbJuIDKNPFHmsk4hwZDO5O+kntRxzaUoNXj+IQ=
+github.com/zeebo/assert v1.3.0/go.mod h1:Pq9JiuJQpG8JLJdtkwrJESF0Foym2/D9XMU5ciN/wJ0=
+github.com/zeebo/xxh3 v1.1.0 h1:s7DLGDK45Dyfg7++yxI0khrfwq9661w9EN78eP/UZVs=
+github.com/zeebo/xxh3 v1.1.0/go.mod h1:IisAie1LELR4xhVinxWS5+zf1lA4p0MW4T+w+W07F5s=
+golang.org/x/sync v0.20.0 h1:e0PTpb7pjO8GAtTs2dQ6jYa5BWYlMuX047Dco/pItO4=
+golang.org/x/sync v0.20.0/go.mod h1:9xrNwdLfx4jkKbNva9FpL6vEN7evnE43NNNJQ2LF3+0=
+golang.org/x/sys v0.42.0 h1:omrd2nAlyT5ESRdCLYdm3+fMfNFE/+Rf4bDIQImRJeo=
+golang.org/x/sys v0.42.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=
+golang.org/x/text v0.35.0 h1:JOVx6vVDFokkpaq1AEptVzLTpDe9KGpj5tR4/X+ybL8=
+golang.org/x/text v0.35.0/go.mod h1:khi/HExzZJ2pGnjenulevKNX1W67CUy0AsXcNubPGCA=
+gotest.tools/v3 v3.5.2 h1:7koQfIKdy+I8UTetycgUqXWSDwpgv193Ka+qRsmBY8Q=
+gotest.tools/v3 v3.5.2/go.mod h1:LtdLGcnqToBH83WByAAi/wiwSFCArdFIUV/xxN4pcjA=

package/lib/api.d.ts

@@ -0,0 +1,91 @@
+import { type ResolveOptions } from "./platform";
+import { type ProjectPluginConfig } from "./project";
+/**
+ * Options shared by every API call. `binary` takes precedence over platform
+ * resolution; `cwd` defaults to `process.cwd()`; `env` layers on top of the
+ * current process env.
+ */
+export interface CommonOptions extends ResolveOptions {
+    /** Absolute path to an already-resolved ttsc binary. Skips resolution. */
+    binary?: string;
+    /** Working directory passed to the child process. */
+    cwd?: string;
+    /** Extra environment variables; merged onto `process.env`. */
+    env?: NodeJS.ProcessEnv;
+    /**
+     * Override project plugin loading. `false` disables tsconfig plugins; an
+     * array replaces the tsconfig `compilerOptions.plugins` list.
+     */
+    plugins?: readonly ProjectPluginConfig[] | false;
+    /**
+     * Override the native rewrite backend. Defaults to the loaded plugin mode.
+     *
+     * @deprecated Prefer plugin-declared `native.mode`; this override is for
+     *   low-level tests and migration probes.
+     */
+    rewriteMode?: string;
+}
+/** Options for `transform()`. */
+export interface TransformOptions extends CommonOptions {
+    /** Path to the .ts file to transform. Absolute or `cwd`-relative. */
+    file: string;
+    /** Path to the tsconfig owning `file`. Default: `tsconfig.json`. */
+    tsconfig?: string;
+    /**
+     * When provided, the binary writes JS directly to this path instead of piping
+     * stdout. Useful when the emitted text is large.
+     */
+    out?: string;
+}
+/** Options for `build()`. */
+export interface BuildOptions extends CommonOptions {
+    /** Path to tsconfig.json. Default: `tsconfig.json`. */
+    tsconfig?: string;
+    /**
+     * Emit override. `true` forces emit, `false` forces noEmit, `undefined`
+     * follows tsconfig.
+     */
+    emit?: boolean;
+    /** Override compilerOptions.outDir for this invocation. */
+    outDir?: string;
+    /** Suppress the per-call summary banner. Default: `true`. */
+    quiet?: boolean;
+}
+/** Options for `check()`. */
+export type CheckOptions = Omit<BuildOptions, "emit">;
+/**
+ * Transform a single .ts file and return the rewritten JS as a string.
+ *
+ * Intended for bundler per-file transforms (unplugin `transform()`). The caller
+ * passes the absolute path; ttsc loads the enclosing tsconfig, compiles with
+ * tsgo, and returns the rewritten JS.
+ *
+ * Throws when the binary exits non-zero — the error includes stderr so bundler
+ * error overlays surface the real cause.
+ */
+export declare function transform(options: TransformOptions): string;
+/** Result of `build()`. Non-zero `status` means the build failed. */
+export interface BuildResult {
+    status: number;
+    stdout: string;
+    stderr: string;
+}
+/**
+ * Run `ttsc` against a tsconfig. Returns once the binary exits so the caller
+ * can decide how to surface diagnostics. Does not throw on non-zero exit —
+ * bundler pipelines often want to continue and collect errors.
+ */
+export declare function build(options?: BuildOptions): BuildResult;
+/**
+ * Run `ttsc check` (build without emit) — CI gate / pre-commit hook use.
+ * Resolves with an exit-code record; does not throw.
+ */
+export declare function check(options?: CheckOptions): BuildResult;
+/** Ask the binary for its version banner. Handy for user-agent strings. */
+export declare function version(options?: CommonOptions): string;
+/**
+ * Promise-facing variant of `transform()`. The plugin host keeps the transform
+ * pipeline synchronous so plugin modules can stay dependency-free, but many
+ * adapter surfaces still prefer a Promise-returning function.
+ */
+export declare function transformAsync(options: TransformOptions): Promise<string>;