ttsc 0.26.1 → 0.26.2

package/src/compiler/internal/runBuild.ts

@@ -38,6 +38,34 @@ export type RunBuildOptions = TtscBuildOptions & {
   forceListEmittedFiles?: boolean;
   /** Keep every compiler-owned side product inside this private directory. */
   isolateOutputsTo?: string;
+  /**
+   * Hand tsgo the `rootDir` it would otherwise infer, for a build whose
+   * `outDir` this process injected rather than the project declaring it.
+   *
+   * Tsgo answers an inferred common source directory with TS5011 the moment an
+   * `outDir` is in play, so injecting one turns a project that declares no
+   * output at all — the `noEmit` check-only shape `tsgo`, `ttsc`, and `ttsc
+   * --emit` all accept — into one that must configure the layout of output the
+   * user never asked for and never sees (issue #1172).
+   *
+   * The pinned value is the one tsgo itself infers: with a config file in play
+   * its common source directory is that file's directory, never the computed
+   * common directory of the input files (`outputpaths.GetCommonSourceDirectory`
+   * consults the file list only for a config-less program). Pinning it
+   * therefore silences the demand without moving a single output, and it is the
+   * same source root `prepareExecution.ts::resolveRuntimeSourceRoot`,
+   * `runtimeHooks.ts::resolveDependencySourceRoot`, and
+   * `watchTopology.ts::inferPerSourceCompilerOutputs` already model on the
+   * JavaScript side.
+   *
+   * Ignored when the project declares its own `rootDir`: that project already
+   * satisfies tsgo, and overriding it would relocate the emit out from under
+   * every consumer that mirrors the declared root.
+   *
+   * Never set for a user-supplied `--outDir`. That outDir is the user's own
+   * request, and TS5011 is then tsgo's genuine answer to it.
+   */
+  pinInferredRootDir?: boolean;
   /**
    * Receives selected native-plugin source roots after the project resolves.
    * The watch launcher uses these roots to invalidate a sidecar when its Go
@@ -1084,7 +1112,7 @@ function forwardsInternalShadowFlag(
  * inside it via the `--plugins-json` flag.
  */
 function buildWithNativeCompilerPlugins(
-  options: TtscBuildOptions,
+  options: RunBuildOptions,
   execution: ReturnType<typeof resolveExecutionContext>,
   plugins: readonly ITtscLoadedNativePlugin[],
   timing: BuildTiming,
@@ -1245,6 +1273,9 @@ function createTsgoBuildArgs(
     if (options.forceRuntimeSourceMap === true) {
       args.push("--sourceMap", "true");
     }
+    // Pushed before passthrough for the same reason: a user `--rootDir` still
+    // wins over the value ttsc pins for its own injected `outDir`.
+    args.push(...pinnedRootDirArgs(execution, options));
   } else if (options.emit === false) {
     args.push("--noEmit");
   }
@@ -1264,6 +1295,37 @@ function createTsgoBuildArgs(
   return args;
 }
 
+/**
+ * The explicit `--rootDir` a caller-injected `outDir` needs, or nothing.
+ *
+ * See {@link RunBuildOptions.pinInferredRootDir} for why an injected `outDir`
+ * needs one at all. Three conditions gate it, and each one is load-bearing:
+ *
+ * - The caller injected the `outDir` itself, so a user `--outDir` keeps tsgo's
+ *   own TS5011 answer;
+ * - This pass emits, because a no-emit pass has no layout to pin (tsgo skips the
+ *   check for `noEmit` too);
+ * - The project declares no `rootDir` of its own, so a declared layout is never
+ *   overridden.
+ *
+ * `execution.projectRoot` is the directory of the tsconfig ttsc resolved and
+ * hands tsgo as `-p`, which is exactly the directory tsgo infers, and it is
+ * spelled the way tsgo will spell the input file names it compares against it —
+ * both come from the same `fs.realpathSync` pass. Resolving it any further (a
+ * Windows 8.3 expansion, say) would leave the comparison lexically mixed, and
+ * `ContainsPath` is lexical: every input would count as outside `rootDir` and
+ * tsgo would emit it beside the user's source instead of under `outDir`.
+ */
+function pinnedRootDirArgs(
+  execution: ReturnType<typeof resolveExecutionContext>,
+  options: RunBuildOptions,
+): string[] {
+  if (options.pinInferredRootDir !== true) return [];
+  if (options.emit !== true) return [];
+  if (typeof execution.project.compilerOptions.rootDir === "string") return [];
+  return ["--rootDir", execution.projectRoot];
+}
+
 /**
  * Return `["--pretty", "false"]` when structured diagnostics are requested so
  * that the output can be parsed line-by-line, or an empty array otherwise.
@@ -1304,7 +1366,7 @@ function createTsgoThreadingArgs(options: TtscCommonOptions): string[] {
 /** Build the argument list for a native plugin `build`/`check` invocation. */
 function createNativeBuildArgs(
   execution: ReturnType<typeof resolveExecutionContext>,
-  options: TtscBuildOptions,
+  options: RunBuildOptions,
   plugins: readonly ITtscLoadedNativePlugin[],
 ): string[] {
   const args = [
@@ -1339,7 +1401,12 @@ function createNativeBuildArgs(
       args.push("--quiet");
     }
   }
-  args.push(...createNativeTsgoArgs(options));
+  // The sidecar builds its Program in-process, so the pinned `rootDir` has to
+  // travel the same channel every other tsgo option takes to it — the host flag
+  // set does not declare `--rootDir`, and `filterHostArgs` would strip it.
+  args.push(
+    ...createNativeTsgoArgs(options, pinnedRootDirArgs(execution, options)),
+  );
   return args;
 }
 
@@ -1488,8 +1555,14 @@ function transformHostTimingLabel(
  * a plugin build the same way it reaches the plain tsgo lane. Encoded as a
  * single token so the sidecars' unknown-flag filters keep it intact.
  */
-function createNativeTsgoArgs(options: TtscCommonOptions): string[] {
+function createNativeTsgoArgs(
+  options: TtscCommonOptions,
+  leading: readonly string[] = [],
+): string[] {
   const passthrough = [
+    // Ahead of the user's own flags, so the same precedence holds here as on
+    // the direct tsgo lane: whatever the user forwarded wins.
+    ...leading,
     ...(nativeTsgoPassthroughArgs(options) ?? []),
     ...isolatedTsgoOutputArgs(options),
   ];

package/src/compiler/internal/runSingleFileEmit.ts

@@ -41,6 +41,13 @@ export function runSingleFileEmit(options: TtscSingleFileEmitOptions): string {
       forceListEmittedFiles: true,
       isolateOutputsTo: outDir,
       outDir,
+      // The private temp directory above is an `outDir` this lane injected, not
+      // one the project declared, and tsgo answers an inferred common source
+      // directory with TS5011 as soon as any `outDir` is in play. Pinning the
+      // root tsgo would infer keeps `ttsc <file.ts>` working on a project that
+      // declares no output at all, and it is the same root
+      // `resolveEmittedJavaScript` mirrors below (issue #1172).
+      pinInferredRootDir: true,
       resolvedProject: project,
       tsconfig,
     });

package/src/flags/schema.ts

@@ -219,6 +219,29 @@ export const FLAG_SCHEMA: readonly FlagSpec[] = [
     description: "Print the launcher version and exit.",
   },
 
+  // -------------------------------------------------------------------------
+  // Solution build mode — declared so the launcher can refuse it in its own
+  // voice instead of forwarding it.
+  //
+  // `createTsgoBuildArgs` opens the forwarded argv with `-p <tsconfig>` because
+  // ttsc resolves the project itself (extends chains, plugin config discovery,
+  // cache keys, resident session identity) and pins the result. A forwarded
+  // `--build` therefore always lands after `-p`, and tsgo answers with TS6369
+  // "Option '--build' must be the first command line argument" — a diagnostic
+  // that contradicts the command line the user actually typed. ttsc's plugin,
+  // cache, and emit architecture is built around one resolved project, so
+  // solution mode is unsupported rather than merely misordered.
+  // -------------------------------------------------------------------------
+  {
+    name: "--build",
+    aliases: ["-b"],
+    kind: "boolean",
+    subcommands: ["ttsc", "ttsx", "build", "check", "fix", "format"],
+    consumedBy: ["launcher"],
+    description:
+      "Refused by the launcher: ttsc pins one resolved project, so tsgo's solution-build mode is unsupported.",
+  },
+
   // -------------------------------------------------------------------------
   // Project location: shared by every subcommand.
   // -------------------------------------------------------------------------

package/src/launcher/internal/assertNoSolutionBuild.ts

@@ -0,0 +1,40 @@
+import { type ParseResult } from "../../flags/parser";
+
+/**
+ * Refuse tsgo's solution-build mode (`--build` / `-b`) in the launcher's own
+ * voice, for whichever launcher parsed the arguments.
+ *
+ * Every ttsc build lane hands tsgo an argument list that opens with the project
+ * ttsc resolved (`-p <tsconfig>` in `createTsgoBuildArgs`), because ttsc — not
+ * tsgo — owns the `extends` chain, plugin config discovery, cache keys, and the
+ * resident session's identity, and pins that one resolved project instead of
+ * forwarding raw argv. A forwarded `--build` therefore always arrives after
+ * `-p`, and tsgo replies "Option '--build' must be the first command line
+ * argument" even though the user wrote it first. No spelling of the command
+ * line can satisfy that diagnostic, so the flag is rejected here rather than
+ * forwarded into an error that blames the user's argument order.
+ *
+ * Both launchers refuse it, because both reach tsgo through the same pinned
+ * project. `ttsx` additionally builds one entry inside that project, so a mode
+ * whose whole purpose is compiling many projects has nothing to mean there
+ * either.
+ *
+ * Presence — not the parsed boolean — is what is refused: `--build false` still
+ * asks for a mode ttsc does not implement, and silently consuming it would drop
+ * the flag with no diagnostic at all.
+ *
+ * What this deliberately does not reach is a `--build` that belongs to the
+ * program `ttsx` is running. `runTtsx` parses with
+ * `forwardAfterFirstPositional` and `honorDoubleDashSeparator`, so a token
+ * after the entry lands in `result.tail` and never in `result.values`; reading
+ * `values` is what keeps `ttsx script.ts --build` the user program's own flag.
+ */
+export function assertNoSolutionBuild(
+  result: ParseResult,
+  errorPrefix: string,
+): void {
+  if (!result.values.has("--build")) return;
+  throw new Error(
+    `${errorPrefix} --build (solution mode) is not supported; ttsc resolves and pins one project per run, so compile each referenced project with its own ttsc -p <tsconfig> run`,
+  );
+}

package/src/launcher/internal/prepareExecution.ts

@@ -57,7 +57,6 @@ export function prepareExecution(
   const context = createProjectContext(
     cwd,
     path.resolve(cwd, entryFile),
-    entry,
     options,
   );
   try {
@@ -151,13 +150,10 @@ function resolveEntrySpelling(cwd: string, entryFile: string): string {
 /**
  * @param discoveryFile - The entry as the user named it. Project discovery
  *   walks up from here, so it must not be retargeted through a symlink.
- * @param entry - The entry in its physical spelling, which is what the emit
- *   layout and the runtime hooks both speak.
  */
 function createProjectContext(
   cwd: string,
   discoveryFile: string,
-  entry: string,
   options: NonNullable<Parameters<typeof prepareExecution>[1]>,
 ) {
   const project = readProjectConfig(
@@ -179,7 +175,7 @@ function createProjectContext(
   const virtualRoot = path.join(processDir, "fs");
   // Resolved once: it now costs a realpath (and, for a missing directory on
   // Windows, a case-sensitivity probe) rather than a string join.
-  const runtimeRootDir = resolveRuntimeSourceRoot(project, entry);
+  const runtimeRootDir = resolveRuntimeSourceRoot(project);
   return {
     project,
     tsconfig,
@@ -217,6 +213,16 @@ function createProjectContext(
  * The source-tree root the emit mirrors, in the same physical spelling as the
  * entry it will be compared against.
  *
+ * Undeclared, the root is the project's own directory, because that is the one
+ * tsgo uses: with a config file in play `GetCommonSourceDirectory` answers that
+ * file's directory and never computes a common directory of the input files.
+ * The entry's directory is not that root — it is only the same directory when
+ * the entry happens to sit beside the tsconfig, which is precisely why a
+ * `src/`-shaped project mislaid its emit here (issue #1172) while a flat one
+ * worked. `runtimeHooks.ts::resolveDependencySourceRoot` and
+ * `watchTopology.ts::inferPerSourceCompilerOutputs` already model the same
+ * rule, and `runBuild.ts::pinnedRootDirArgs` pins it for tsgo itself.
+ *
  * Resolving it is the other half of `resolveEntrySpelling`, and skipping it
  * leaves the comparison mixed rather than merely imprecise. `project.root`
  * arrives through plain `fs.realpathSync`, which resolves reparse points but
@@ -227,22 +233,25 @@ function createProjectContext(
  * way the gate reads an in-project entry as outside its own root, pays a second
  * whole build for it, and publishes a wider root than the project has.
  *
- * `path.dirname(entry)` is already physical, so only the declared branch needs
- * the pass.
+ * The pass costs nothing in agreement with the root tsgo was pinned to, which
+ * stays unresolved on purpose so it matches the spelling tsgo gives the input
+ * file names it compares against it. Only the prefix differs between the two;
+ * each side strips its own, so the relative path below the root — the part that
+ * decides where the emit lands and where the lookup reads — is identical.
  */
 function resolveRuntimeSourceRoot(
   project: ReturnType<typeof readProjectConfig>,
-  entry: string,
 ): string {
   const rootDir = project.compilerOptions.rootDir;
-  if (typeof rootDir !== "string") {
-    return path.dirname(entry);
-  }
   const identities = createFilesystemPathIdentityContext({
     throwOnRealpathError: false,
   });
   return identities.resolve(
-    path.isAbsolute(rootDir) ? rootDir : path.resolve(project.root, rootDir),
+    typeof rootDir !== "string"
+      ? project.root
+      : path.isAbsolute(rootDir)
+        ? rootDir
+        : path.resolve(project.root, rootDir),
   ).path;
 }
 
@@ -265,6 +274,13 @@ function buildProject(
     cacheDir: context.pluginCacheDir,
     outDir: context.emitDir,
     passthrough: options.passthrough,
+    // `context.emitDir` is ttsx's own temp directory, not an output the project
+    // asked for, and tsgo demands an explicit `rootDir` (TS5011) as soon as any
+    // `outDir` is in play. Pinning the root tsgo would infer keeps a check-only
+    // project runnable without moving its emit (issue #1172); a project that
+    // declares `rootDir` is left exactly as it is, which is also the root
+    // `resolveRuntimeSourceRoot` published above.
+    pinInferredRootDir: true,
     // Emit a source map on the transient entry emit (a PID-isolated temp dir,
     // never the consumer's `outDir`) so the serve path can inline it under the
     // source URL. Routed as a dedicated build option, not a forwarded tsgo

package/src/launcher/internal/runTtsc.ts

@@ -27,6 +27,7 @@ import {
 import type { ITtscProjectInputSnapshot } from "../../structures/internal/ITtscProjectInputSnapshot";
 import type { TtscBuildOptions } from "../../structures/internal/TtscBuildOptions";
 import type { TtscSingleFileEmitOptions } from "../../structures/internal/TtscSingleFileEmitOptions";
+import { assertNoSolutionBuild } from "./assertNoSolutionBuild";
 import { getCompilerVersionText } from "./getCompilerVersionText";
 import { resolveCacheDir } from "./resolveCacheDir";
 import { resolveSingleFileOutput } from "./singleFileOutput";
@@ -441,6 +442,7 @@ function parseBuildArgs(argv: readonly string[]) {
     isPositional: looksLikeInputFile,
     subcommand: "build",
   });
+  assertNoSolutionBuild(result, "ttsc:");
   // Defaults: pinned by the previous hand-parser. `quiet` defaults true,
   // `--verbose` flips it to false; `emit` defaults `undefined` so the resolved
   // project controls ordinary build mode. `runCompatibleBuild` applies the

package/src/launcher/internal/runTtsx.ts

@@ -11,6 +11,7 @@ import {
   parseFlags,
 } from "../../flags/parser";
 import { resolveFlagSpec } from "../../flags/schema";
+import { assertNoSolutionBuild } from "./assertNoSolutionBuild";
 import { getCompilerVersionText } from "./getCompilerVersionText";
 import { prepareExecution } from "./prepareExecution";
 import { resolveCacheDir } from "./resolveCacheDir";
@@ -130,6 +131,7 @@ function parseCLI(argv: readonly string[]) {
     isPositional: looksLikeEntryFile,
     subcommand: "ttsx",
   });
+  assertNoSolutionBuild(result, "ttsx:");
 
   const entry = result.positional.find(looksLikeEntryFile);
   if (entry === undefined) {

package/src/launcher/internal/runtimeHooks.ts

@@ -1527,6 +1527,13 @@ function buildDependency(
     emit: true,
     forceListEmittedFiles: true,
     outDir: emitDir,
+    // The generation directory is an `outDir` this lane injected, not one the
+    // dependency declared, and tsgo demands an explicit `rootDir` (TS5011) as
+    // soon as any `outDir` is in play. Pinning the root tsgo would infer keeps
+    // a source-shipping dependency that declares no output buildable, and it is
+    // the same root `resolveDependencySourceRoot` publishes for it below —
+    // without it that dependency falls back to type-stripping (issue #1172).
+    pinInferredRootDir: true,
     // Emit a source map on the transient dependency emit (it never reaches the
     // dependency's published `lib/`) so the serve path can inline it under the
     // source URL, but only when the dependency configures none itself. Routed