ttsc 0.8.1 → 0.10.0

package/src/plugin/internal/buildSourcePlugin.ts

@@ -1,19 +1,16 @@
 import { spawnSync } from "node:child_process";
-import * as crypto from "node:crypto";
-import * as fs from "node:fs";
+import crypto from "node:crypto";
+import fs from "node:fs";
 import { createRequire } from "node:module";
-import * as path from "node:path";
+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 SKIP_DIRS = new Set([
-  "node_modules",
-  ".git",
-  "dist",
-  "build",
-  "vendor",
-  "lib",
-]);
+const PRUNE_DIRS = new Set(["node_modules", ".git", ".ttsc"]);
+const GENERATED_WORKSPACE_FILES = new Set(["go.work", "go.work.sum"]);
 
 /** Build one Go source plugin into a cached executable. */
 export function buildSourcePlugin(opts: {
@@ -28,9 +25,14 @@ export function buildSourcePlugin(opts: {
   tsgoVersion: string;
 }): string {
   const { dir, entry, source } = resolveSourceBuildTarget(opts);
+  const overlayDirs = opts.overlayDirs ?? findTtscOverlayDirs();
+  const goBinary = resolveGoCompiler();
+  ensureExecutableGoToolchain(goBinary);
   const key = computeCacheKey({
     dir,
     entry,
+    goBinary,
+    overlayDirs,
     ttscVersion: opts.ttscVersion,
     tsgoVersion: opts.tsgoVersion,
   });
@@ -49,27 +51,46 @@ export function buildSourcePlugin(opts: {
     );
   }
 
-  const scratchDir = path.join(
-    root,
-    `scratch-${key}-${process.pid}-${Date.now()}`,
+  const scratchDir = fs.mkdtempSync(
+    path.join(os.tmpdir(), `ttsc-plugin-${key}-`),
   );
   try {
     materializeScratchDir(dir, scratchDir);
-    writeGoWork(scratchDir, opts.overlayDirs ?? findTtscOverlayDirs());
+    writeGoWork(scratchDir, overlayDirs, goBinary, opts.pluginName);
     const scratchBinaryName =
       process.platform === "win32" ? ".ttsc-plugin.exe" : ".ttsc-plugin";
-    runGoBuild(scratchDir, entry, scratchBinaryName, opts.pluginName);
+    runGoBuild(scratchDir, entry, scratchBinaryName, opts.pluginName, goBinary);
     const builtBinary = path.join(scratchDir, scratchBinaryName);
-    fs.renameSync(builtBinary, binaryPath);
-    if (process.platform !== "win32") {
-      fs.chmodSync(binaryPath, 0o755);
-    }
+    publishBuiltBinary(builtBinary, binaryPath);
     return binaryPath;
   } finally {
     fs.rmSync(scratchDir, { recursive: true, force: true });
   }
 }
 
+function publishBuiltBinary(builtBinary: string, binaryPath: string): void {
+  const pending = `${binaryPath}.${process.pid}.${Date.now()}-${Math.random()
+    .toString(16)
+    .slice(2)}.tmp`;
+  fs.copyFileSync(builtBinary, pending);
+  if (process.platform !== "win32") {
+    fs.chmodSync(pending, 0o755);
+  }
+  try {
+    fs.renameSync(pending, binaryPath);
+  } catch (error) {
+    fs.rmSync(pending, { force: true });
+    const code = (error as NodeJS.ErrnoException).code;
+    if (
+      (code === "EEXIST" || code === "EPERM" || code === "EACCES") &&
+      fs.existsSync(binaryPath)
+    ) {
+      return;
+    }
+    throw error;
+  }
+}
+
 function resolveSourceBuildTarget(opts: {
   source: string;
   pluginName: string;
@@ -136,52 +157,221 @@ function materializeScratchDir(source: string, scratch: string): void {
     recursive: true,
     filter: (src) => {
       const base = path.basename(src);
-      if (SKIP_DIRS.has(base)) return false;
-      if (base === "go.work" || base === "go.work.sum") return false;
+      if (shouldPruneDirectory(base)) return false;
+      if (shouldOmitSourceFile(base)) return false;
       return true;
     },
   });
 }
 
-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 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 escapeRegExp(value: string): string {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+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(
@@ -189,8 +379,8 @@ function runGoBuild(
   entry: string,
   binaryName: string,
   pluginName: string,
+  goBinary: string,
 ): void {
-  const goBinary = resolveGoCompiler();
   ensureExecutableGoToolchain(goBinary);
   const result = spawnSync(goBinary, ["build", "-o", binaryName, entry], {
     cwd,
@@ -201,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}`,
@@ -218,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);
@@ -305,7 +499,7 @@ function walkForGoMod(dir: string, out: string[]): void {
   }
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
-    if (SKIP_DIRS.has(entry.name)) continue;
+    if (shouldPruneDirectory(entry.name)) continue;
     walkForGoMod(path.join(dir, entry.name), out);
   }
 }
@@ -315,7 +509,7 @@ function resolvePluginCacheRoot(
   cacheDir?: string,
 ): string {
   if (cacheDir) {
-    return path.resolve(cacheDir, "plugins");
+    return path.resolve(projectRoot, cacheDir, "plugins");
   }
   if (process.env.TTSC_CACHE_DIR) {
     return path.resolve(process.env.TTSC_CACHE_DIR, "plugins");
@@ -387,9 +581,11 @@ function resolveGoCompiler(): string {
   return "go";
 }
 
-function computeCacheKey(inputs: {
+export function computeCacheKey(inputs: {
   dir: string;
   entry: string;
+  goBinary?: string;
+  overlayDirs?: readonly string[];
   ttscVersion: string;
   tsgoVersion: string;
 }): string {
@@ -398,12 +594,28 @@ function computeCacheKey(inputs: {
   hash.update(`tsgo=${inputs.tsgoVersion}\n`);
   hash.update(`platform=${process.platform}/${process.arch}\n`);
   hash.update(`entry=${inputs.entry}\n`);
-  for (const file of collectSourceFiles(inputs.dir)) {
-    const rel = path.relative(inputs.dir, file).replace(/\\/g, "/");
+  if (inputs.goBinary !== undefined) {
+    hash.update(`go=${resolveGoCompilerIdentity(inputs.goBinary)}\n`);
+  }
+  hashSourceDirectory(hash, "plugin", inputs.dir);
+  for (const [index, dir] of [...(inputs.overlayDirs ?? [])].sort().entries()) {
+    hashSourceDirectory(hash, `overlay:${index}`, dir);
+  }
+  return hash.digest("hex").slice(0, 32);
+}
+
+function hashSourceDirectory(
+  hash: crypto.Hash,
+  label: string,
+  root: string,
+): void {
+  hash.update(`dir=${label}\n`);
+  for (const file of collectSourceFiles(root)) {
+    const rel = path.relative(root, file).replace(/\\/g, "/");
     hash.update(`f=${rel}\n`);
     hash.update(fs.readFileSync(file));
+    hash.update("\n");
   }
-  return hash.digest("hex").slice(0, 32);
 }
 
 function collectSourceFiles(root: string): string[] {
@@ -421,19 +633,78 @@ function walk(dir: string, out: string[]): void {
     return;
   }
   for (const entry of entries) {
-    if (SKIP_DIRS.has(entry.name)) continue;
     const full = path.join(dir, entry.name);
     if (entry.isDirectory()) {
+      if (shouldPruneDirectory(entry.name)) continue;
       walk(full, out);
       continue;
     }
     if (!entry.isFile()) continue;
+    if (shouldOmitSourceFile(entry.name)) continue;
     if (!isHashableFile(entry.name)) continue;
     out.push(full);
   }
 }
 
+function shouldPruneDirectory(name: string): boolean {
+  return PRUNE_DIRS.has(name);
+}
+
+function shouldOmitSourceFile(name: string): boolean {
+  return GENERATED_WORKSPACE_FILES.has(name);
+}
+
 function isHashableFile(name: string): boolean {
-  if (name === "go.mod" || name === "go.sum" || name === "go.work") return true;
-  return /\.(?:go|s|c|h|cpp|hpp)$/i.test(name);
+  return !name.endsWith("~");
+}
+
+function resolveGoCompilerIdentity(goBinary: string): string {
+  const resolved = resolveExecutableIdentityPath(goBinary);
+  const version = spawnSync(goBinary, ["version"], {
+    encoding: "utf8",
+    windowsHide: true,
+  });
+  const versionText =
+    version.error !== undefined
+      ? version.error.message
+      : `${version.status ?? 0}:${version.stdout}${version.stderr}`;
+  let statText = "";
+  try {
+    const stat = fs.statSync(resolved);
+    statText = `${stat.size}:${stat.mtimeMs}`;
+  } catch {
+    statText = "missing";
+  }
+  return `${goBinary}:${resolved}:${statText}:${versionText}`;
+}
+
+function resolveExecutableIdentityPath(binary: string): string {
+  if (path.isAbsolute(binary)) {
+    return resolveRealPath(binary);
+  }
+  if (binary.includes(path.sep)) {
+    return resolveRealPath(path.resolve(binary));
+  }
+  for (const dir of (process.env.PATH ?? "").split(path.delimiter)) {
+    if (dir.length === 0) continue;
+    const candidate = path.join(dir, binary);
+    if (fs.existsSync(candidate)) {
+      return resolveRealPath(candidate);
+    }
+    if (process.platform === "win32") {
+      const executable = `${candidate}.exe`;
+      if (fs.existsSync(executable)) {
+        return resolveRealPath(executable);
+      }
+    }
+  }
+  return binary;
+}
+
+function resolveRealPath(location: string): string {
+  try {
+    return fs.realpathSync(location);
+  } catch {
+    return location;
+  }
 }