ttsc 0.21.0 → 0.23.0

package/src/compiler/internal/runSingleFileEmit.ts

@@ -39,6 +39,7 @@ export function runSingleFileEmit(options: TtscSingleFileEmitOptions): string {
       cwd,
       emit: true,
       forceListEmittedFiles: true,
+      isolateOutputsTo: outDir,
       outDir,
       resolvedProject: project,
       tsconfig,

package/src/flags/parser.ts

@@ -156,12 +156,9 @@ export function parseFlags(opts: ParseOptions): ParseResult {
     // `--target all` masquerade as `--all` now that the lookup is dash- and
     // case-insensitive.
     if (current.startsWith("-")) {
-      // `--foo=value` / `-p=value` form: split before resolving against the
-      // schema. Both long (`--foo`) and short (`-p`) aliases support the
-      // inline-value shape — without splitting the short form, `-p=value`
-      // would fall through as an unknown token and be forwarded to tsgo,
-      // bypassing the launcher's own consumer (e.g. plugin discovery against
-      // the wrong project root).
+      // Split `--foo=value` / `-p=value` before resolving launcher-owned
+      // options. A tsgo-only option is still forwarded byte-for-byte; pinned
+      // tsgo does not split `=`, so it will reject that spelling itself.
       const equalsIndex = current.indexOf("=");
       const token =
         equalsIndex === -1 ? current : current.slice(0, equalsIndex);
@@ -369,13 +366,10 @@ function validatePositiveInt(
  * `--tsgo-args`); without this branch the parser would lose the value token of
  * a `--flag value` pair.
  *
- * `isPositional` is the same predicate the main loop applies, and applying it
- * here is what makes the file's own claim true — that the two value-resolution
- * paths agree, and that the predicate is the only signal separating a forwarded
- * value from a real input. Without it this branch took the next bare token on
- * behalf of a flag that does not own it, so `ttsc --pretty a.ts` lost `a.ts`
- * out of `positional` and silently switched from single-file mode to project
- * mode (issue #663's failure shape, reached through the sibling branch).
+ * A value option owned by tsgo always consumes its next bare token, even when
+ * it ends in `.ts`; `--rootDir src.ts main.ts` has one option value and one
+ * source. Schema rows belonging only to another ttsc layer still consult
+ * `isPositional`, because tsgo does not own their arity.
  */
 function forwardKnownButUnaccepted(
   passthrough: string[],
@@ -386,15 +380,21 @@ function forwardKnownButUnaccepted(
   isPositional: ((token: string) => boolean) | undefined,
 ): void {
   passthrough.push(original);
-  // Boolean flags carry no value. `--foo=value` already encodes the value
-  // inline. Otherwise the next argv token is the flag's value: keep it
-  // adjacent so tsgo receives the pair intact.
+  // Boolean flags carry no required value. `--foo=value` is already one token.
   if (flag.kind === "boolean" || inlineValue !== undefined) {
     return;
   }
   if (rest.length === 0) return;
   if (rest[0]!.startsWith("-")) return;
-  if (isPositional !== undefined && isPositional(rest[0]!)) return;
+  const tsgoOwnsArity =
+    flag.consumedBy.includes("tsgo") || flag.forwardTo === "tsgo";
+  if (
+    tsgoOwnsArity === false &&
+    isPositional !== undefined &&
+    isPositional(rest[0]!)
+  ) {
+    return;
+  }
   passthrough.push(rest.shift()!);
 }
 

package/src/flags/schema.ts

@@ -61,9 +61,10 @@ export type FlagLayer =
 /**
  * Argument shape of a flag.
  *
- * - `boolean` — `--flag` / `--flag=true` / `--flag=false`. No value token is
- *   consumed.
- * - `value` — `--flag value` or `--flag=value`. Required value.
+ * - `boolean` — `--flag` with an optional spaced `true` / `false`. Launcher flags
+ *   also accept `--flag=true` / `--flag=false`; tsgo-forwarded flags stay
+ *   verbatim because pinned tsgo does not split `=`.
+ * - `value` — `--flag value`. Launcher flags also accept `--flag=value`.
  * - `valueOptional` — `--flag` standalone is allowed; if followed by a non-flag
  *   token that token is consumed as the value. (Currently unused — declared for
  *   future flags like `--watch [path]`.)
@@ -161,6 +162,13 @@ export interface FlagSpec {
    */
   readonly internalShadow?: boolean;
 
+  /**
+   * `true` when pinned tsgo only permits the option in tsconfig, except for
+   * command-line `false` or `null`. The launcher forwards the original argv so
+   * tsgo remains the diagnostic authority.
+   */
+  readonly tsconfigOnly?: boolean;
+
   /**
    * Native sidecar capability that must be declared before ttsc sends this flag
    * as a bare CLI argument. Everything else routes through `--tsgo-args` or
@@ -275,6 +283,107 @@ export const FLAG_SCHEMA: readonly FlagSpec[] = [
     consumedBy: ["launcher", "host", "lint"],
     description: "Override compilerOptions.outDir for this invocation.",
   },
+  {
+    name: "--composite",
+    kind: "boolean",
+    subcommands: ["ttsc", "ttsx", "build", "check", "fix", "format"],
+    consumedBy: ["tsgo"],
+    forwardTo: "tsgo",
+    tsconfigOnly: true,
+    description:
+      "Configure project-reference constraints in tsconfig; CLI accepts only false or null.",
+  },
+  {
+    name: "--incremental",
+    aliases: ["-i"],
+    kind: "boolean",
+    subcommands: ["ttsc", "ttsx", "build", "check", "fix", "format"],
+    consumedBy: ["tsgo"],
+    forwardTo: "tsgo",
+    description: "Write build information for incremental compilation.",
+  },
+  {
+    name: "--tsBuildInfoFile",
+    kind: "value",
+    subcommands: ["ttsc", "ttsx", "build", "check", "fix", "format"],
+    consumedBy: ["tsgo"],
+    forwardTo: "tsgo",
+    description: "Choose the incremental build-information file.",
+  },
+  {
+    name: "--declaration",
+    aliases: ["-d"],
+    kind: "boolean",
+    subcommands: ["ttsc", "ttsx", "build", "check", "fix", "format"],
+    consumedBy: ["tsgo"],
+    forwardTo: "tsgo",
+    description: "Emit declaration files.",
+  },
+  {
+    name: "--declarationDir",
+    kind: "value",
+    subcommands: ["ttsc", "ttsx", "build", "check", "fix", "format"],
+    consumedBy: ["tsgo"],
+    forwardTo: "tsgo",
+    description: "Choose the declaration output directory.",
+  },
+  {
+    name: "--declarationMap",
+    kind: "boolean",
+    subcommands: ["ttsc", "ttsx", "build", "check", "fix", "format"],
+    consumedBy: ["tsgo"],
+    forwardTo: "tsgo",
+    description: "Emit source maps for declaration files.",
+  },
+  {
+    name: "--emitDeclarationOnly",
+    kind: "boolean",
+    subcommands: ["ttsc", "ttsx", "build", "check", "fix", "format"],
+    consumedBy: ["tsgo"],
+    forwardTo: "tsgo",
+    description: "Emit declarations without JavaScript.",
+  },
+  {
+    name: "--inlineSourceMap",
+    kind: "boolean",
+    subcommands: ["ttsc", "ttsx", "build", "check", "fix", "format"],
+    consumedBy: ["tsgo"],
+    forwardTo: "tsgo",
+    description: "Inline source maps into emitted JavaScript.",
+  },
+  {
+    name: "--sourceMap",
+    kind: "boolean",
+    subcommands: ["ttsc", "ttsx", "build", "check", "fix", "format"],
+    consumedBy: ["tsgo"],
+    forwardTo: "tsgo",
+    description: "Emit external JavaScript source maps.",
+  },
+  {
+    name: "--outFile",
+    kind: "value",
+    subcommands: ["ttsc", "ttsx", "build", "check", "fix", "format"],
+    consumedBy: ["tsgo"],
+    forwardTo: "tsgo",
+    description:
+      "Forward the removed legacy option for TypeScript-Go's diagnostic.",
+  },
+  {
+    name: "--rootDir",
+    kind: "value",
+    subcommands: ["ttsc", "ttsx", "build", "check", "fix", "format"],
+    consumedBy: ["tsgo"],
+    forwardTo: "tsgo",
+    description: "Choose the compiler input root.",
+  },
+  {
+    name: "--jsx",
+    kind: "value",
+    subcommands: ["ttsc", "ttsx", "build", "check", "fix", "format"],
+    consumedBy: ["tsgo"],
+    forwardTo: "tsgo",
+    description: "Choose the JSX emit transform.",
+  },
 
   // -------------------------------------------------------------------------
   // Watch mode (launcher only).

package/src/internal/projectInputPathIdentity.ts

@@ -0,0 +1,377 @@
+import childProcess from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+
+import { parseWindowsDirectoryCaseSensitivity } from "./windowsDirectoryCaseSensitivity";
+
+export type FilesystemPathIdentity = {
+  key: string;
+  path: string;
+};
+
+export type FilesystemPathIdentityOperations = {
+  caseSensitive(directory: string): boolean;
+  platform: NodeJS.Platform;
+  realpath(location: string): string;
+  throwOnRealpathError: boolean;
+};
+
+export type FilesystemPathIdentityContext = {
+  caseSensitive(directory: string): boolean;
+  isWithin(root: string, candidate: string): boolean;
+  resolve(location: string): FilesystemPathIdentity;
+};
+
+type CachedIdentity = {
+  ancestor: string;
+  identity: FilesystemPathIdentity;
+};
+
+type CachedRealpath =
+  | {
+      found: false;
+    }
+  | {
+      found: true;
+      path: string;
+    };
+
+/**
+ * Create one filesystem-identity resolver for a filesystem transaction.
+ *
+ * Existing segments use their physical spelling. A missing suffix keeps exact
+ * spelling only under a case-sensitive directory; otherwise its canonical
+ * spelling is folded so aliases remain one declaration before they exist.
+ */
+export function createFilesystemPathIdentityContext(
+  operations: Partial<FilesystemPathIdentityOperations> = {},
+): FilesystemPathIdentityContext {
+  const identities = new Map<string, CachedIdentity>();
+  const realpaths = new Map<string, CachedRealpath>();
+  const sensitivities = new Map<string, boolean>();
+  const platform = operations.platform ?? process.platform;
+  const pathApi = platform === "win32" ? path.win32 : path;
+  const throwOnRealpathError = operations.throwOnRealpathError ?? true;
+  const realpath = operations.realpath ?? physicalRealpath;
+  const caseSensitive =
+    operations.caseSensitive ??
+    ((directory: string) =>
+      filesystemDirectoryIsCaseSensitive(directory, platform));
+
+  const resolve = (location: string): FilesystemPathIdentity => {
+    const normalized = resolveFilesystemPath(location, platform);
+    const cached = identities.get(normalized);
+    if (cached !== undefined) return cached.identity;
+    let existing = normalized;
+    const missing: string[] = [];
+    while (true) {
+      const physical = cachedRealpath(
+        realpaths,
+        realpath,
+        existing,
+        platform,
+        throwOnRealpathError,
+      );
+      if (physical !== undefined) {
+        const sensitive =
+          missing.length === 0
+            ? true
+            : cachedCaseSensitivity(sensitivities, caseSensitive, physical);
+        const suffix = sensitive
+          ? missing
+          : missing.map((segment) => segment.toLowerCase());
+        const canonical = pathApi.resolve(physical, ...suffix);
+        const identity = {
+          key: filesystemPathIdentityKey(canonical, platform),
+          path: canonical,
+        };
+        identities.set(normalized, {
+          ancestor: physical,
+          identity,
+        });
+        return identity;
+      }
+      const parent = pathApi.dirname(existing);
+      if (parent === existing) {
+        const sensitive = cachedCaseSensitivity(
+          sensitivities,
+          caseSensitive,
+          existing,
+        );
+        const identity = {
+          key: filesystemPathIdentityKey(
+            sensitive ? normalized : normalized.toLowerCase(),
+            platform,
+          ),
+          path: normalized,
+        };
+        identities.set(normalized, {
+          ancestor: normalized,
+          identity,
+        });
+        return identity;
+      }
+      missing.unshift(pathApi.basename(existing));
+      existing = parent;
+    }
+  };
+
+  return {
+    caseSensitive: (directory) => {
+      const normalized = resolveFilesystemPath(directory, platform);
+      resolve(normalized);
+      return cachedCaseSensitivity(
+        sensitivities,
+        caseSensitive,
+        identities.get(normalized)!.ancestor,
+      );
+    },
+    isWithin: (root, candidate) =>
+      isFilesystemPathIdentityWithin(
+        resolve(root).key,
+        resolve(candidate).key,
+        platform,
+      ),
+    resolve,
+  };
+}
+
+export function isFilesystemPathIdentityWithin(
+  root: string,
+  candidate: string,
+  platform: NodeJS.Platform = process.platform,
+): boolean {
+  if (candidate === root) return true;
+  const separator = platform === "win32" ? path.win32.sep : path.sep;
+  return candidate.startsWith(
+    root.endsWith(separator) ? root : `${root}${separator}`,
+  );
+}
+
+export function resolveFilesystemPath(
+  location: string,
+  platform: NodeJS.Platform = process.platform,
+): string {
+  const pathApi = platform === "win32" ? path.win32 : path;
+  if (platform !== "win32") {
+    return pathApi.resolve(location);
+  }
+  const normalized = location.replaceAll("/", "\\");
+  if (normalized.toLowerCase().startsWith("\\\\?\\unc\\")) {
+    return pathApi.resolve(`\\\\${normalized.slice(8)}`);
+  }
+  if (
+    normalized.startsWith("\\\\?\\") &&
+    /^[A-Za-z]:\\/.test(normalized.slice(4))
+  ) {
+    return pathApi.resolve(normalized.slice(4));
+  }
+  return pathApi.resolve(normalized);
+}
+
+function cachedRealpath(
+  cache: Map<string, CachedRealpath>,
+  realpath: (location: string) => string,
+  location: string,
+  platform: NodeJS.Platform,
+  throwOnRealpathError: boolean,
+): string | undefined {
+  const cached = cache.get(location);
+  if (cached !== undefined) return cached.found ? cached.path : undefined;
+  try {
+    const physical = resolveFilesystemPath(realpath(location), platform);
+    cache.set(location, { found: true, path: physical });
+    return physical;
+  } catch (error) {
+    if (throwOnRealpathError && isMissingFilesystemEntry(error) === false) {
+      throw error;
+    }
+    cache.set(location, { found: false });
+    return undefined;
+  }
+}
+
+function cachedCaseSensitivity(
+  cache: Map<string, boolean>,
+  caseSensitive: (directory: string) => boolean,
+  directory: string,
+): boolean {
+  const cached = cache.get(directory);
+  if (cached !== undefined) return cached;
+  const sensitive = caseSensitive(directory);
+  cache.set(directory, sensitive);
+  return sensitive;
+}
+
+function physicalRealpath(location: string): string {
+  return fs.realpathSync.native?.(location) ?? fs.realpathSync(location);
+}
+
+function filesystemDirectoryIsCaseSensitive(
+  directory: string,
+  platform: NodeJS.Platform,
+): boolean {
+  let entries: string[];
+  try {
+    entries = fs.readdirSync(directory);
+  } catch {
+    return unprovenCaseSensitivity(platform);
+  }
+  const foldedNames = new Map<string, string>();
+  for (const name of entries) {
+    const folded = name.toLowerCase();
+    const previous = foldedNames.get(folded);
+    if (previous !== undefined && previous !== name) return true;
+    foldedNames.set(folded, name);
+  }
+  let rejectedAlternate = false;
+  for (const name of entries) {
+    const alternate = alternateCase(name);
+    if (alternate === name) continue;
+    try {
+      fs.lstatSync(path.join(directory, alternate));
+      return false;
+    } catch (error) {
+      if (isMissingFilesystemEntry(error)) {
+        rejectedAlternate = true;
+        continue;
+      }
+      throw error;
+    }
+  }
+  if (rejectedAlternate) return true;
+  if (platform === "darwin") {
+    // APFS/HFS case semantics are volume-wide. An empty directory has no child
+    // name to probe, so ask the same read-only question of its existing name in
+    // the parent and walk upward until a name with ASCII case is available.
+    // This avoids a write probe while still distinguishing default APFS from a
+    // case-sensitive volume.
+    let current = resolveFilesystemPath(directory, platform);
+    while (true) {
+      const parent = path.dirname(current);
+      if (parent === current) break;
+      const name = path.basename(current);
+      const alternate = alternateCase(name);
+      if (alternate !== name) {
+        try {
+          physicalRealpath(path.join(parent, alternate));
+          return false;
+        } catch (error) {
+          if (isMissingFilesystemEntry(error) === false) throw error;
+        }
+      }
+      current = parent;
+    }
+    return unprovenCaseSensitivity(platform);
+  }
+  if (platform !== "win32") return true;
+  // Node does not expose the Windows per-directory flag. Prefer fsutil's
+  // read-only answer, then conservatively preserve distinct declarations.
+  const queried = queryWindowsDirectoryCaseSensitivity(directory);
+  if (queried !== undefined) return queried;
+  return unprovenCaseSensitivity(platform);
+}
+
+/**
+ * Read the per-directory flag without depending on fsutil's display language.
+ *
+ * English output is cheap to recognize directly. Other Windows locales write
+ * console-code-page bytes that Node cannot reliably decode, so their raw
+ * message is interpreted against the volume-root query.
+ */
+function queryWindowsDirectoryCaseSensitivity(
+  directory: string,
+): boolean | undefined {
+  const result = queryWindowsDirectoryCaseSensitivityBytes(directory);
+  if (result === undefined) return undefined;
+  const volumeRoot = path.win32.parse(directory).root;
+  const direct = parseWindowsDirectoryCaseSensitivity(
+    result,
+    undefined,
+    volumeRoot,
+  );
+  if (direct !== undefined) return direct;
+  const volume = queryWindowsDirectoryCaseSensitivityBytes(volumeRoot);
+  return parseWindowsDirectoryCaseSensitivity(result, volume, volumeRoot);
+}
+
+function queryWindowsDirectoryCaseSensitivityBytes(
+  directory: string,
+): Buffer | undefined {
+  const result = childProcess.spawnSync(
+    "fsutil.exe",
+    ["file", "queryCaseSensitiveInfo", directory],
+    { windowsHide: true },
+  );
+  return result.error === undefined &&
+    result.status === 0 &&
+    Buffer.isBuffer(result.stdout)
+    ? result.stdout
+    : undefined;
+}
+
+/**
+ * What to assume when the volume refused to answer.
+ *
+ * Every probe above returns a proof: two names that fold together prove the
+ * volume keeps them apart, and a name that opens under the other case proves it
+ * does not. This is the remaining case — an empty or unreadable directory, a
+ * name with no letter to alter, a Windows build whose `fsutil` lacks the
+ * subcommand — and the only honest answer is the platform's own default.
+ *
+ * NTFS and APFS are case-insensitive unless a volume or a directory was opted
+ * out, so guessing sensitive there splits one file into two identities under
+ * two spellings, which is the failure this module exists to remove. The rarer
+ * mistake, on a volume that really was opted out, merges two files differing
+ * only in case into one watched identity.
+ */
+function unprovenCaseSensitivity(platform: NodeJS.Platform): boolean {
+  return platform !== "win32" && platform !== "darwin";
+}
+
+function filesystemPathIdentityKey(
+  location: string,
+  platform: NodeJS.Platform,
+): string {
+  if (platform !== "win32") return location;
+  const root = path.win32.parse(location).root;
+  return `${root.toLowerCase()}${location.slice(root.length)}`;
+}
+
+function alternateCase(value: string): string {
+  return value.replace(/[A-Za-z]/g, (character) =>
+    character === character.toLowerCase()
+      ? character.toUpperCase()
+      : character.toLowerCase(),
+  );
+}
+
+function isMissingFilesystemEntry(error: unknown): boolean {
+  return (
+    error instanceof Error &&
+    "code" in error &&
+    (error.code === "ENOENT" || error.code === "ENOTDIR")
+  );
+}
+
+export type ProjectInputPathIdentity = FilesystemPathIdentity;
+export type ProjectInputPathIdentityOperations =
+  FilesystemPathIdentityOperations;
+export type ProjectInputPathIdentityContext = FilesystemPathIdentityContext;
+
+export function createProjectInputPathIdentityContext(
+  operations: Partial<ProjectInputPathIdentityOperations> = {},
+): ProjectInputPathIdentityContext {
+  return createFilesystemPathIdentityContext(operations);
+}
+
+export function isProjectInputPathIdentityWithin(
+  root: string,
+  candidate: string,
+): boolean {
+  return isFilesystemPathIdentityWithin(root, candidate);
+}
+
+export function resolveProjectInputPath(location: string): string {
+  return resolveFilesystemPath(location);
+}

package/src/internal/windowsDirectoryCaseSensitivity.ts

@@ -0,0 +1,33 @@
+/**
+ * Interpret fsutil's case-sensitivity query without assuming a display
+ * language.
+ *
+ * English messages identify the state directly. For every other locale, the
+ * volume-root query supplies the raw localized suffix for the ordinary disabled
+ * state. A target with that suffix is insensitive; a different successful
+ * message is the enabled state.
+ */
+export function parseWindowsDirectoryCaseSensitivity(
+  directoryOutput: Buffer,
+  volumeOutput: Buffer | undefined,
+  volumeRoot: string,
+): boolean | undefined {
+  const text = directoryOutput.toString("utf8");
+  if (/\bdisabled\b/iu.test(text)) return false;
+  if (/\benabled\b/iu.test(text)) return true;
+  if (volumeOutput === undefined) return undefined;
+
+  const encodedRoot = Buffer.from(volumeRoot, "utf8");
+  const rootOffset = volumeOutput.lastIndexOf(encodedRoot);
+  if (rootOffset === -1) return undefined;
+  const disabledSuffix = volumeOutput.subarray(rootOffset + encodedRoot.length);
+  if (
+    disabledSuffix.length === 0 ||
+    directoryOutput.length < disabledSuffix.length
+  ) {
+    return undefined;
+  }
+  return !directoryOutput
+    .subarray(directoryOutput.length - disabledSuffix.length)
+    .equals(disabledSuffix);
+}