ttsc 0.9.0 → 0.10.1

package/shim/printer/go.mod

@@ -0,0 +1,5 @@
+module github.com/microsoft/typescript-go/shim/printer
+
+go 1.26
+
+require github.com/microsoft/typescript-go v0.0.0-20260429010842-56ab4af42157

package/shim/printer/shim.go

@@ -0,0 +1,23 @@
+package printer
+
+import (
+	"github.com/microsoft/typescript-go/internal/ast"
+	innerprinter "github.com/microsoft/typescript-go/internal/printer"
+)
+
+type PrintHandlers = innerprinter.PrintHandlers
+type Printer = innerprinter.Printer
+type PrinterOptions = innerprinter.PrinterOptions
+type EmitContext = innerprinter.EmitContext
+
+func NewPrinter(options PrinterOptions, handlers PrintHandlers, emitContext *EmitContext) *Printer {
+	return innerprinter.NewPrinter(options, handlers, emitContext)
+}
+
+func NewEmitContext() *EmitContext {
+	return innerprinter.NewEmitContext()
+}
+
+func EmitSourceFile(p *Printer, sourceFile *ast.SourceFile) string {
+	return p.EmitSourceFile(sourceFile)
+}

package/src/compiler/internal/compileProjectInMemory.ts

@@ -29,7 +29,7 @@ export function compileProjectInMemory(options: ITtscCompilerContext): {
   const tsconfig = project.path;
   const binary = buildNativeCompiler({
     cacheBaseDir: project.root,
-    cacheDir: options.cacheDir,
+    cacheDir: options.cacheDir ?? options.env?.TTSC_CACHE_DIR,
     packageRoot: packageRootDir(),
   });
   const res = spawnSync(

package/src/compiler/internal/transformProjectInMemory.ts

@@ -50,7 +50,7 @@ function transformProjectWithNativeHost(
 } {
   const binary = buildNativeCompiler({
     cacheBaseDir: project.root,
-    cacheDir: options.cacheDir,
+    cacheDir: options.cacheDir ?? options.env?.TTSC_CACHE_DIR,
     packageRoot: packageRootDir(),
   });
   const res = spawnNative(

package/src/plugin/internal/buildSourcePlugin.ts

@@ -6,6 +6,8 @@ import os from "node:os";
 import path from "node:path";
 
 const GO_MOD_SEARCH_MAX_DEPTH = 3;
+const TTSC_GO_MODULE_PATH = "github.com/samchon/ttsc/packages/ttsc";
+const TSGO_GO_MODULE_PATH = "github.com/microsoft/typescript-go";
 
 const PRUNE_DIRS = new Set(["node_modules", ".git", ".ttsc"]);
 const GENERATED_WORKSPACE_FILES = new Set(["go.work", "go.work.sum"]);
@@ -25,6 +27,7 @@ export function buildSourcePlugin(opts: {
   const { dir, entry, source } = resolveSourceBuildTarget(opts);
   const overlayDirs = opts.overlayDirs ?? findTtscOverlayDirs();
   const goBinary = resolveGoCompiler();
+  ensureExecutableGoToolchain(goBinary);
   const key = computeCacheKey({
     dir,
     entry,
@@ -53,7 +56,7 @@ export function buildSourcePlugin(opts: {
   );
   try {
     materializeScratchDir(dir, scratchDir);
-    writeGoWork(scratchDir, overlayDirs);
+    writeGoWork(scratchDir, overlayDirs, goBinary, opts.pluginName);
     const scratchBinaryName =
       process.platform === "win32" ? ".ttsc-plugin.exe" : ".ttsc-plugin";
     runGoBuild(scratchDir, entry, scratchBinaryName, opts.pluginName, goBinary);
@@ -161,45 +164,214 @@ function materializeScratchDir(source: string, scratch: string): void {
   });
 }
 
-function writeGoWork(scratchDir: string, useDirs: readonly string[]): void {
+function writeGoWork(
+  scratchDir: string,
+  useDirs: readonly string[],
+  goBinary: string,
+  pluginName: string,
+): void {
+  const goModReader = createGoModReader(goBinary, pluginName);
+  validateSourceReplacements(
+    scratchDir,
+    useDirs,
+    goModReader,
+    pluginName,
+  );
   const useLines = ["\t."];
   for (const dir of useDirs) {
     useLines.push(`\t${dir.replace(/\\/g, "/")}`);
   }
-  const replaceLines = sourceBuildWorkspaceReplacements(useDirs);
+  const replaceLines = sourceBuildWorkspaceReplacements(
+    useDirs,
+    goModReader,
+  );
   const replaceBlock =
     replaceLines.length === 0 ? "" : `\n\n${replaceLines.join("\n")}\n`;
   const goWork = `go 1.26\n\nuse (\n${useLines.join("\n")}\n)${replaceBlock}`;
   fs.writeFileSync(path.join(scratchDir, "go.work"), goWork, "utf8");
 }
 
+function validateSourceReplacements(
+  scratchDir: string,
+  useDirs: readonly string[],
+  goModReader: GoModReader,
+  pluginName: string,
+): void {
+  const sourceInfo = goModReader.read(scratchDir);
+  if (sourceInfo.modulePath === TTSC_GO_MODULE_PATH) {
+    return;
+  }
+  const sourceReplacements = sourceInfo.replacements;
+  if (sourceReplacements.length === 0) {
+    return;
+  }
+  const overlayModules = collectOverlayModulePaths(useDirs, goModReader);
+  for (const replacement of sourceReplacements) {
+    if (
+      isTtscManagedModulePath(replacement.modulePath) ||
+      overlayModules.has(replacement.modulePath)
+    ) {
+      throw new Error(
+        `ttsc: plugin "${pluginName}" go.mod replaces ttsc-managed module ` +
+          `${JSON.stringify(replacement.modulePath)}. Remove this replace directive; ` +
+          `ttsc supplies its own compiler and shim modules while building source plugins.`,
+      );
+    }
+  }
+}
+
 function sourceBuildWorkspaceReplacements(
   useDirs: readonly string[],
+  goModReader: GoModReader,
 ): string[] {
-  const ttscRoot = useDirs.find((dir) =>
-    hasModulePath(dir, "github.com/samchon/ttsc/packages/ttsc"),
+  const ttscRoot = useDirs.find(
+    (dir) => goModReader.read(dir).modulePath === TTSC_GO_MODULE_PATH,
   );
   if (!ttscRoot) {
     return [];
   }
   return [
-    `replace github.com/samchon/ttsc/packages/ttsc v0.0.0 => ${ttscRoot.replace(/\\/g, "/")}`,
+    `replace ${TTSC_GO_MODULE_PATH} v0.0.0 => ${ttscRoot.replace(/\\/g, "/")}`,
   ];
 }
 
-function hasModulePath(dir: string, modulePath: string): boolean {
+interface GoModReplacement {
+  readonly modulePath: string;
+}
+
+interface GoModInfo {
+  readonly modulePath: string | null;
+  readonly replacements: readonly GoModReplacement[];
+}
+
+interface GoModReader {
+  read(dir: string): GoModInfo;
+}
+
+interface GoModJson {
+  readonly Module?: {
+    readonly Path?: string;
+  };
+  readonly Require?: readonly {
+    readonly Path?: string;
+    readonly Version?: string;
+  }[];
+  readonly Replace?: readonly {
+    readonly Old?: {
+      readonly Path?: string;
+      readonly Version?: string;
+    };
+    readonly New?: {
+      readonly Path?: string;
+      readonly Version?: string;
+    };
+  }[];
+}
+
+function createGoModReader(goBinary: string, pluginName: string): GoModReader {
+  const cache = new Map<string, GoModInfo>();
+  return {
+    read(dir) {
+      const resolved = path.resolve(dir);
+      const cached = cache.get(resolved);
+      if (cached !== undefined) {
+        return cached;
+      }
+      const info = readGoModInfo(resolved, goBinary, pluginName);
+      cache.set(resolved, info);
+      return info;
+    },
+  };
+}
+
+function readGoModInfo(
+  dir: string,
+  goBinary: string,
+  pluginName: string,
+): GoModInfo {
+  if (!fs.existsSync(path.join(dir, "go.mod"))) {
+    return emptyGoModInfo();
+  }
+
+  const result = spawnSync(goBinary, ["mod", "edit", "-json"], {
+    cwd: dir,
+    encoding: "utf8",
+    env: goBuildEnv(goBinary),
+    maxBuffer: 1024 * 1024 * 16,
+    windowsHide: true,
+  });
+  if (result.error) {
+    if ((result.error as NodeJS.ErrnoException).code === "ENOENT") {
+      throw new Error(goToolchainNotFoundMessage(pluginName));
+    }
+    throw new Error(
+      `ttsc: reading go.mod for plugin "${pluginName}" failed to spawn ${goBinary}: ${result.error.message}`,
+    );
+  }
+  if (result.status !== 0) {
+    throw new Error(
+      `ttsc: reading go.mod for plugin "${pluginName}" failed:\n${result.stderr || result.stdout}`,
+    );
+  }
+
+  let json: GoModJson;
   try {
-    const goMod = fs.readFileSync(path.join(dir, "go.mod"), "utf8");
-    return new RegExp(`^module\\s+${escapeRegExp(modulePath)}\\s*$`, "m").test(
-      goMod,
+    json = JSON.parse(result.stdout) as GoModJson;
+  } catch (error) {
+    throw new Error(
+      `ttsc: reading go.mod for plugin "${pluginName}" returned invalid JSON: ${
+        error instanceof Error ? error.message : String(error)
+      }`,
     );
-  } catch {
-    return false;
   }
+
+  return {
+    modulePath: json.Module?.Path ?? null,
+    replacements: (json.Replace ?? [])
+      .map(jsonReplacementToGoModReplacement)
+      .filter((replacement) => replacement !== null),
+  };
 }
 
-function escapeRegExp(value: string): string {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+function emptyGoModInfo(): GoModInfo {
+  return {
+    modulePath: null,
+    replacements: [],
+  };
+}
+
+function jsonReplacementToGoModReplacement(
+  replacement: NonNullable<GoModJson["Replace"]>[number],
+): GoModReplacement | null {
+  const modulePath = replacement.Old?.Path;
+  if (modulePath === undefined) {
+    return null;
+  }
+  return {
+    modulePath,
+  };
+}
+
+function collectOverlayModulePaths(
+  dirs: readonly string[],
+  goModReader: GoModReader,
+): Set<string> {
+  const out = new Set<string>();
+  for (const dir of dirs) {
+    const modulePath = goModReader.read(dir).modulePath;
+    if (modulePath !== null) {
+      out.add(modulePath);
+    }
+  }
+  return out;
+}
+
+function isTtscManagedModulePath(modulePath: string): boolean {
+  return (
+    modulePath === TTSC_GO_MODULE_PATH ||
+    modulePath === TSGO_GO_MODULE_PATH ||
+    modulePath.startsWith("github.com/microsoft/typescript-go/shim/")
+  );
 }
 
 function runGoBuild(
@@ -219,11 +391,7 @@ function runGoBuild(
   });
   if (result.error) {
     if ((result.error as NodeJS.ErrnoException).code === "ENOENT") {
-      throw new Error(
-        `ttsc: building plugin "${pluginName}" failed because the Go toolchain was not found. ` +
-          `Reinstall ttsc with optional dependencies so the bundled Go compiler is present, ` +
-          `or set TTSC_GO_BINARY to an absolute path.`,
-      );
+      throw new Error(goToolchainNotFoundMessage(pluginName));
     }
     throw new Error(
       `ttsc: building plugin "${pluginName}" failed to spawn ${goBinary}: ${result.error.message}`,
@@ -236,6 +404,14 @@ function runGoBuild(
   }
 }
 
+function goToolchainNotFoundMessage(pluginName: string): string {
+  return (
+    `ttsc: building plugin "${pluginName}" failed because the Go toolchain was not found. ` +
+    `Reinstall ttsc with optional dependencies so the bundled Go compiler is present, ` +
+    `or set TTSC_GO_BINARY to an absolute path.`
+  );
+}
+
 function goBuildEnv(goBinary: string): NodeJS.ProcessEnv {
   const env = { ...process.env };
   const goRoot = inferGoRoot(goBinary);

package/src/plugin/internal/loadProjectPlugins.ts

@@ -64,12 +64,15 @@ export function loadProjectPlugins(options: {
     projectRoot: project.root,
     tsconfig: project.path,
   };
-  const plugins = entries.map((entry) =>
+  const plugins = composePluginSources(
+    entries,
+    entries.map((entry) =>
     loadPluginEntry(
       entry.config,
       { ...context, plugin: entry.config },
       entry.baseDir,
     ),
+    ),
   );
 
   const nativePlugins: ITtscLoadedNativePlugin[] = [];
@@ -100,6 +103,36 @@ export function loadProjectPlugins(options: {
   };
 }
 
+function composePluginSources(
+  entries: readonly ProjectPluginEntry[],
+  plugins: readonly ITtscPlugin[],
+): ITtscPlugin[] {
+  const aggregates = plugins
+    .map((plugin, index) => ({ index, plugin }))
+    .filter(({ plugin }) => Array.isArray(plugin.composes));
+  if (aggregates.length === 0) {
+    return [...plugins];
+  }
+  return plugins.map((plugin, index) => {
+    const transform = entries[index]?.config.transform;
+    const aggregate = aggregates.find(
+      ({ index: aggregateIndex, plugin: aggregatePlugin }) =>
+        aggregateIndex !== index &&
+        aggregatePlugin.composes!.some(
+          (alias) =>
+            alias === plugin.name ||
+            (typeof transform === "string" && alias === transform),
+        ),
+    );
+    return aggregate === undefined
+      ? plugin
+      : {
+          ...plugin,
+          source: aggregate.plugin.source,
+        };
+  });
+}
+
 export function hasProjectPluginEntries(
   project: ITtscParsedProjectConfig,
   entries?: readonly ITtscProjectPluginConfig[] | false,

package/src/structures/ITtscPlugin.ts

@@ -45,6 +45,17 @@ export interface ITtscPlugin {
    */
   source: string;
 
+  /**
+   * Other transform plugin names or transform specifiers that this native
+   * sidecar can execute in the same compiler pass.
+   *
+   * Package auto-discovery may find multiple transform packages that must share
+   * one emit host. When one descriptor lists another entry here, ttsc keeps the
+   * original plugin config in `--plugins-json` but points the composed entry at
+   * this descriptor's native source so both entries resolve to one binary.
+   */
+  composes?: string[];
+
   /**
    * Pipeline stage implemented by the sidecar.
    *

package/utility/host.go

@@ -13,6 +13,7 @@ import (
   shimast "github.com/microsoft/typescript-go/shim/ast"
   shimcompiler "github.com/microsoft/typescript-go/shim/compiler"
   shimcore "github.com/microsoft/typescript-go/shim/core"
+  shimprinter "github.com/microsoft/typescript-go/shim/printer"
 
   "github.com/samchon/ttsc/packages/ttsc/driver"
 )
@@ -108,14 +109,19 @@ func RunTransform(args []string) int {
   if !ok {
     return 2
   }
-  prog, _, _, _, ok := loadUtilityProgram(opts)
+  prog, _, _, sourcePreamble, ok := loadUtilityProgram(opts)
   if !ok {
     return 2
   }
   defer prog.Close()
+  printer := shimprinter.NewPrinter(shimprinter.PrinterOptions{}, shimprinter.PrintHandlers{}, nil)
   out := transformResult{TypeScript: map[string]string{}}
   for _, file := range prog.SourceFiles() {
-    out.TypeScript[apiOutputKey(opts.cwd, file.FileName())] = file.Text()
+    text := shimprinter.EmitSourceFile(printer, file)
+    if sourcePreamble != "" && !shouldRemoveComments(prog) && !strings.Contains(text, sourcePreamble) {
+      text = driver.ApplySourcePreamble(text, sourcePreamble)
+    }
+    out.TypeScript[apiOutputKey(opts.cwd, file.FileName())] = text
   }
   data, err := json.Marshal(out)
   if err != nil {
@@ -140,6 +146,10 @@ func parseHostOptions(command string, args []string) (hostOptions, bool) {
   if err := fs.Parse(filterHostArgs(args)); err != nil {
     return hostOptions{}, false
   }
+  if *emit && *noEmit {
+    fmt.Fprintln(os.Stderr, "ttsc utility: --emit and --noEmit are mutually exclusive")
+    return hostOptions{}, false
+  }
   resolvedCwd := *cwd
   if resolvedCwd == "" {
     var err error