ttsc 0.3.0 → 0.4.0-dev.20260424

package/cmd/ttsc/transform.go

@@ -0,0 +1,166 @@
+package main
+
+import (
+	"bytes"
+	"flag"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+
+	shimcompiler "github.com/microsoft/typescript-go/shim/compiler"
+
+	"github.com/samchon/ttsc/packages/ttsc/driver"
+)
+
+// runTransform implements `ttsc transform` — a single-file transform used by
+// bundler plugin adapters (unplugin, vite, webpack, rollup, esbuild, rspack,
+// farm). Behavior:
+//
+//   - Loads the enclosing tsconfig so tsgo resolves imports and types.
+//   - Runs tsgo Emit, filtering WriteFile so only the requested source
+//     file's JS leaves the binary.
+//   - Applies the ttsc rewrite + import cleanup just like `build --emit`.
+//   - Writes the result to stdout (or `--out` when provided).
+//
+// The contract matches a per-file bundler transform hook: bundlers
+// hand the plugin a source file path, the plugin shells out here, and the
+// returned text replaces the file in the bundle graph.
+func runTransform(args []string) int {
+	fs := flag.NewFlagSet("transform", flag.ContinueOnError)
+	fs.SetOutput(stderr)
+	file := fs.String("file", "", "absolute or cwd-relative path of the .ts file to transform")
+	tsconfigPath := fs.String("tsconfig", "tsconfig.json", "tsconfig.json owning --file")
+	cwdOverride := fs.String("cwd", "", "override the working directory")
+	out := fs.String("out", "", "write output JS to PATH (default: stdout)")
+	rewriteMode := fs.String("rewrite-mode", "none", "native rewrite backend id")
+	if err := fs.Parse(args); err != nil {
+		return 2
+	}
+	if *file == "" {
+		fmt.Fprintln(stderr, "ttsc transform: --file is required")
+		return 2
+	}
+
+	cwd := *cwdOverride
+	if cwd == "" {
+		var err error
+		cwd, err = os.Getwd()
+		if err != nil {
+			fmt.Fprintf(stderr, "ttsc transform: cwd: %v\n", err)
+			return 2
+		}
+	}
+
+	prog, diags, err := driver.LoadProgram(cwd, *tsconfigPath, driver.LoadProgramOptions{
+		ForceEmit: true,
+	})
+	if err != nil {
+		fmt.Fprintf(stderr, "ttsc transform: %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
+	}
+
+	absFile := *file
+	if !filepath.IsAbs(absFile) {
+		absFile = filepath.Join(cwd, absFile)
+	}
+	absFile = filepath.ToSlash(absFile)
+
+	rewrites := driver.NewRewriteSet()
+	if *rewriteMode != "none" {
+		fmt.Fprintf(stderr, "ttsc transform: rewrite backend %q is not built into the standalone ttsc binary\n", *rewriteMode)
+		fmt.Fprintln(stderr, "ttsc transform: run through the JS host with the matching compiler plugin so it can select the consumer-provided native binary")
+		return 2
+	}
+
+	target := prog.SourceFile(absFile)
+	if target == nil {
+		fmt.Fprintf(stderr, "ttsc transform: source file is not in program: %s\n", absFile)
+		return 2
+	}
+
+	// Capture the requested source file's JS output.
+	var captured []byte
+	capture := func(name, text string, _ *shimcompiler.WriteFileData) error {
+		rel := filepath.ToSlash(name)
+		if !isJavaScriptOutput(rel) {
+			return nil
+		}
+		captured = []byte(text)
+		return nil
+	}
+	_, eDiags, err := prog.EmitFile(rewrites, target, capture)
+	if err != nil {
+		fmt.Fprintf(stderr, "ttsc transform: emit: %v\n", err)
+		return 3
+	}
+	for _, d := range eDiags {
+		fmt.Fprintln(stderr, "  -", d.String())
+	}
+	if captured == nil {
+		fmt.Fprintf(stderr, "ttsc transform: no output produced for %s\n", absFile)
+		return 3
+	}
+	if *out == "" {
+		if _, werr := bytes.NewReader(captured).WriteTo(stdout); werr != nil {
+			fmt.Fprintf(stderr, "ttsc transform: write stdout: %v\n", werr)
+			return 3
+		}
+		return 0
+	}
+	if dir := filepath.Dir(*out); dir != "" {
+		if err := os.MkdirAll(dir, 0o755); err != nil {
+			fmt.Fprintf(stderr, "ttsc transform: mkdir: %v\n", err)
+			return 3
+		}
+	}
+	if err := os.WriteFile(*out, captured, 0o644); err != nil {
+		fmt.Fprintf(stderr, "ttsc transform: write %s: %v\n", *out, err)
+		return 3
+	}
+	return 0
+}
+
+// sharedSourceStemSegments counts the shared trailing path segments between the
+// emitted output path and the original source path after stripping extensions.
+// `src/foo/bar.ts` ↔ `dist/foo/bar.js` returns 2, while unrelated paths return
+// 0. `ttsc transform` uses the highest score to pick the emitted JS that
+// belongs to the requested source file even when a project contains multiple
+// `index.ts` files.
+func sharedSourceStemSegments(outPath, srcPath string) int {
+	trim := func(p string) []string {
+		p = strings.TrimSuffix(p, filepath.Ext(p))
+		return strings.Split(p, "/")
+	}
+	a, b := trim(outPath), trim(srcPath)
+	n := len(a)
+	if len(b) < n {
+		n = len(b)
+	}
+	shared := 0
+	for i := 1; i <= n; i++ {
+		if a[len(a)-i] != b[len(b)-i] {
+			break
+		}
+		shared++
+	}
+	return shared
+}
+
+func isJavaScriptOutput(name string) bool {
+	switch strings.ToLower(filepath.Ext(name)) {
+	case ".js", ".mjs", ".cjs":
+		return true
+	default:
+		return false
+	}
+}

package/driver/host.go

@@ -0,0 +1,31 @@
+// Package driver wraps the typescript-go compiler so the rest of ttsc doesn't
+// need to know about shim packages directly. It is the only part of the engine
+// that imports `shim/*` by design — everything downstream consumes a small,
+// shim-agnostic interface (`*Program`).
+//
+// Structural note: this file is deliberately adapted from tsgonest's
+// `internal/compiler/host.go` (MIT, github.com/tsgonest/tsgonest).
+// The helper surface is the same; we keep names in sync to make future
+// upstream changes easy to compare.
+package driver
+
+import (
+	"github.com/microsoft/typescript-go/shim/bundled"
+	shimcompiler "github.com/microsoft/typescript-go/shim/compiler"
+	"github.com/microsoft/typescript-go/shim/vfs"
+	"github.com/microsoft/typescript-go/shim/vfs/cachedvfs"
+	"github.com/microsoft/typescript-go/shim/vfs/osvfs"
+)
+
+// DefaultFS returns an OS-backed filesystem wrapped with tsgo's bundled libs so
+// built-in definitions (lib.es*.d.ts, dom, etc.) resolve without a network
+// fetch. Mirrors tsgonest/tsgolint behavior.
+func DefaultFS() vfs.FS {
+	return bundled.WrapFS(cachedvfs.From(osvfs.FS()))
+}
+
+// DefaultHost returns a CompilerHost anchored at cwd that can find tsgo's
+// bundled library files via `bundled.LibPath()`.
+func DefaultHost(cwd string, fs vfs.FS) shimcompiler.CompilerHost {
+	return shimcompiler.NewCompilerHost(cwd, fs, bundled.LibPath(), nil, nil)
+}

package/driver/program.go

@@ -0,0 +1,298 @@
+package driver
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"io"
+	"path/filepath"
+
+	"github.com/microsoft/typescript-go/shim/ast"
+	shimchecker "github.com/microsoft/typescript-go/shim/checker"
+	shimcompiler "github.com/microsoft/typescript-go/shim/compiler"
+	"github.com/microsoft/typescript-go/shim/core"
+	shimdiagnosticwriter "github.com/microsoft/typescript-go/shim/diagnosticwriter"
+	shimscanner "github.com/microsoft/typescript-go/shim/scanner"
+	"github.com/microsoft/typescript-go/shim/tsoptions"
+	"github.com/microsoft/typescript-go/shim/tspath"
+	"github.com/microsoft/typescript-go/shim/vfs"
+)
+
+// Diagnostic is the compilation diagnostic shape ttsc passes around. Kept
+// dependency-free (no shim types) so callers can render or inspect freely.
+type Diagnostic struct {
+	File    string
+	Line    int
+	Column  int
+	Message string
+	raw     *ast.Diagnostic
+}
+
+// SourceFile returns the program source file matching filename.
+func (p *Program) SourceFile(filename string) *ast.SourceFile {
+	if p == nil || p.TSProgram == nil {
+		return nil
+	}
+	normalized := filepath.ToSlash(filename)
+	for _, file := range p.TSProgram.SourceFiles() {
+		if filepath.ToSlash(file.FileName()) == normalized {
+			return file
+		}
+	}
+	return nil
+}
+
+// String returns a `path:line:col: message` formatted string.
+func (d Diagnostic) String() string {
+	if d.File == "" {
+		return d.Message
+	}
+	if d.Line > 0 {
+		return fmt.Sprintf("%s:%d:%d: %s", d.File, d.Line, d.Column, d.Message)
+	}
+	return fmt.Sprintf("%s: %s", d.File, d.Message)
+}
+
+// WritePrettyDiagnostics renders diagnostics with TypeScript-style colors,
+// source snippets and the trailing error summary when raw tsgo diagnostic
+// objects are available. It falls back to the legacy one-line form for
+// diagnostics assembled outside tsgo.
+func WritePrettyDiagnostics(w io.Writer, diagnostics []Diagnostic, cwd string) {
+	raw := make([]*ast.Diagnostic, 0, len(diagnostics))
+	for _, d := range diagnostics {
+		if d.raw == nil {
+			for _, d := range diagnostics {
+				fmt.Fprintln(w, "  -", d.String())
+			}
+			return
+		}
+		raw = append(raw, d.raw)
+	}
+	shimdiagnosticwriter.FormatASTDiagnosticsWithColorAndContext(w, raw, cwd)
+}
+
+// Program is the shim-agnostic facade the rest of the engine sees.
+type Program struct {
+	TSProgram      *shimcompiler.Program
+	ParsedConfig   *tsoptions.ParsedCommandLine
+	Checker        *shimchecker.Checker
+	checkerRelease func()
+	Host           shimcompiler.CompilerHost
+	FS             vfs.FS
+}
+
+// LoadProgramOptions controls tsconfig overrides applied before tsgo creates
+// the program. `ForceEmit` is used by `ttsc --emit` and `ttsc transform`
+// so runtime compilation still works when the project defaults to `noEmit`.
+type LoadProgramOptions struct {
+	ForceEmit   bool
+	ForceNoEmit bool
+	OutDir      string
+}
+
+// Close releases the checker pool lease acquired by LoadProgram.
+func (p *Program) Close() error {
+	if p.checkerRelease != nil {
+		p.checkerRelease()
+		p.checkerRelease = nil
+	}
+	return nil
+}
+
+// ParseTSConfig parses a tsconfig.json file via tsgo's native JSONC parser.
+// Comments, trailing commas, and `extends` chains are handled automatically.
+//
+// The absolute path is resolved against cwd before any VFS lookups because
+// tsgo's filesystem APIs require absolute paths — mirrors what tsc does when
+// you pass a relative `--project` flag.
+func ParseTSConfig(fs vfs.FS, cwd, tsconfigPath string, host shimcompiler.CompilerHost) (*tsoptions.ParsedCommandLine, []Diagnostic, error) {
+	resolved := tspath.ResolvePath(cwd, tsconfigPath)
+	if !fs.FileExists(resolved) {
+		return nil, nil, fmt.Errorf("tsconfig not found: %s", resolved)
+	}
+	parsed, diags := tsoptions.GetParsedCommandLineOfConfigFile(resolved, &core.CompilerOptions{}, nil, host, nil)
+	if len(diags) > 0 {
+		return nil, convertDiagnostics(diags), nil
+	}
+	if parsed == nil {
+		return nil, nil, errors.New("tsoptions: parsed command line was nil")
+	}
+	if len(parsed.Errors) > 0 {
+		return nil, convertDiagnostics(parsed.Errors), nil
+	}
+	return parsed, nil, nil
+}
+
+// CreateProgramFromConfig builds a tsgo Program from the parsed config.
+func CreateProgramFromConfig(parsed *tsoptions.ParsedCommandLine, host shimcompiler.CompilerHost) (*shimcompiler.Program, []Diagnostic, error) {
+	opts := shimcompiler.ProgramOptions{
+		Config:                      parsed,
+		SingleThreaded:              core.TSTrue,
+		Host:                        host,
+		UseSourceOfProjectReference: true,
+	}
+	p := shimcompiler.NewProgram(opts)
+	if p == nil {
+		return nil, nil, errors.New("shimcompiler.NewProgram returned nil")
+	}
+	return p, nil, nil
+}
+
+// LoadProgram is the one-shot convenience used by `ttsc`.
+// It parses the tsconfig, creates a program and a type-checker, and returns
+// the wrapped facade.
+//
+// cwd must be absolute; tsconfigPath may be relative to cwd.
+func LoadProgram(cwd, tsconfigPath string, options LoadProgramOptions) (*Program, []Diagnostic, error) {
+	if !filepath.IsAbs(cwd) {
+		if abs, err := filepath.Abs(cwd); err == nil {
+			cwd = abs
+		}
+	}
+	cwd = tspath.ResolvePath(cwd)
+	fs := DefaultFS()
+	host := DefaultHost(cwd, fs)
+
+	parsed, diags, err := ParseTSConfig(fs, cwd, tsconfigPath, host)
+	if err != nil {
+		return nil, nil, err
+	}
+	if len(diags) > 0 {
+		return nil, diags, nil
+	}
+	if options.ForceNoEmit {
+		forceNoEmit(parsed)
+	}
+	if options.ForceEmit {
+		forceEmit(parsed)
+	}
+	if options.OutDir != "" {
+		overrideOutDir(cwd, parsed, options.OutDir)
+	}
+
+	tsProgram, progDiags, err := CreateProgramFromConfig(parsed, host)
+	if err != nil {
+		return nil, nil, err
+	}
+	if len(progDiags) > 0 {
+		return nil, progDiags, nil
+	}
+
+	checker, done := tsProgram.GetTypeChecker(context.Background())
+	return &Program{
+		TSProgram:      tsProgram,
+		ParsedConfig:   parsed,
+		Checker:        checker,
+		checkerRelease: done,
+		Host:           host,
+		FS:             fs,
+	}, nil, nil
+}
+
+func forceEmit(parsed *tsoptions.ParsedCommandLine) {
+	if parsed == nil || parsed.ParsedConfig == nil || parsed.ParsedConfig.CompilerOptions == nil {
+		return
+	}
+	options := parsed.ParsedConfig.CompilerOptions
+	options.NoEmit = core.TSFalse
+	options.EmitDeclarationOnly = core.TSFalse
+}
+
+func forceNoEmit(parsed *tsoptions.ParsedCommandLine) {
+	if parsed == nil || parsed.ParsedConfig == nil || parsed.ParsedConfig.CompilerOptions == nil {
+		return
+	}
+	parsed.ParsedConfig.CompilerOptions.NoEmit = core.TSTrue
+}
+
+func overrideOutDir(cwd string, parsed *tsoptions.ParsedCommandLine, outDir string) {
+	if parsed == nil || parsed.ParsedConfig == nil || parsed.ParsedConfig.CompilerOptions == nil {
+		return
+	}
+	parsed.ParsedConfig.CompilerOptions.OutDir = tspath.ResolvePath(cwd, outDir)
+}
+
+// SourceFiles exposes the program's user-authored source files (declaration
+// files filtered out).
+func (p *Program) SourceFiles() []*ast.SourceFile {
+	out := make([]*ast.SourceFile, 0)
+	for _, f := range p.TSProgram.SourceFiles() {
+		if f.IsDeclarationFile {
+			continue
+		}
+		out = append(out, f)
+	}
+	return out
+}
+
+// Diagnostics returns project diagnostics that must block compilation or
+// runtime execution before any JavaScript is emitted or evaluated.
+func (p *Program) Diagnostics() []Diagnostic {
+	if p == nil || p.TSProgram == nil {
+		return []Diagnostic{{Message: "driver: nil program"}}
+	}
+	ctx := context.Background()
+	raw := shimcompiler.GetDiagnosticsOfAnyProgram(
+		ctx,
+		p.TSProgram,
+		nil,
+		false,
+		p.TSProgram.GetBindDiagnostics,
+		p.TSProgram.GetSemanticDiagnostics,
+	)
+	raw = filterDiagnostics(raw)
+	return convertDiagnostics(shimcompiler.SortAndDeduplicateDiagnostics(raw))
+}
+
+func filterDiagnostics(in []*ast.Diagnostic) []*ast.Diagnostic {
+	out := in[:0]
+	for _, d := range in {
+		if isUnusedOverloadSignatureTypeParameterDiagnostic(d) {
+			continue
+		}
+		out = append(out, d)
+	}
+	return out
+}
+
+func isUnusedOverloadSignatureTypeParameterDiagnostic(d *ast.Diagnostic) bool {
+	if d == nil || d.File() == nil {
+		return false
+	}
+	switch d.Code() {
+	case 6196, 6205: // unused declaration / all type parameters are unused
+	default:
+		return false
+	}
+	node := ast.GetNodeAtPosition(d.File(), d.Pos(), false)
+	for node != nil {
+		if node.Kind == ast.KindFunctionDeclaration {
+			return node.Body() == nil
+		}
+		node = node.Parent
+	}
+	return false
+}
+
+// convertDiagnostics translates shim-specific diagnostics into the plain
+// Diagnostic struct with line/column populated via tsgo's ECMALineMap (the
+// same helper tsc uses for its "file:line:col: message" banner).
+func convertDiagnostics(in []*ast.Diagnostic) []Diagnostic {
+	out := make([]Diagnostic, 0, len(in))
+	for _, d := range in {
+		if d == nil {
+			continue
+		}
+		diag := Diagnostic{Message: d.String(), raw: d}
+		if file := d.File(); file != nil {
+			diag.File = file.FileName()
+			if pos := d.Pos(); pos >= 0 {
+				line, col := shimscanner.GetECMALineAndByteOffsetOfPosition(file, pos)
+				diag.Line = line + 1
+				diag.Column = col + 1
+			}
+		}
+		out = append(out, diag)
+	}
+	return out
+}