@ttsc/unplugin 0.30.1 → 0.30.2

package/src/core/transform.ts

@@ -21,6 +21,7 @@ import {
   findNearestProjectTsconfig,
   isIgnoredProjectDirectory,
 } from "./projectDiscovery";
+import { matchesProjectRootFile } from "./projectRootFiles";
 import {
   CONFIG_DIR_TEMPLATE_LIST_OPTIONS,
   CONFIG_DIR_TEMPLATE_SCALAR_OPTIONS,
@@ -2624,6 +2625,29 @@ function matchesCachedSource(
     cached.sourceHashes?.[identity] ??
     cached.inputHashes[currentKey] ??
     cached.externalInputHashes?.[identity];
+  if (
+    expected === undefined &&
+    cached.result.type === "success" &&
+    !matchesProjectRootFile(file, cached.membershipPolicy, false)
+  ) {
+    const state = envelopeDerivation(cached);
+    const outputs = (state.outputIndex ??= createEnvelopeKeyIndex(
+      state,
+      cached.projectRoot,
+      cached.result.typescript,
+    ));
+    if (!outputs.has(identity)) {
+      // Root discovery deliberately never hashed this unrelated module. Its
+      // bytes cannot affect an output the compiler did not produce, but the
+      // whole program must still be current before we reuse that absence: a
+      // changed config or importer can bring this file into the next program.
+      refreshFilesystemClockReference(
+        TRANSFORM_CLOCK_REFERENCE_DIRECTORIES.get(cached),
+        resultFilesystem(cached.result),
+      );
+      return matchesCompleteInputSnapshot(cached, currentKey, source);
+    }
+  }
   if (expected !== hashText(source)) {
     return false;
   }
@@ -4442,7 +4466,10 @@ function walkProjectInputs(
         continue;
       }
       const file = path.join(current, entry.name);
-      if (entry.isDirectory() && isExcludedProjectDirectory(file, policy)) {
+      if (
+        (entry.isDirectory() && isExcludedProjectDirectory(file, policy)) ||
+        !matchesProjectRootFile(file, policy, entry.isDirectory())
+      ) {
         continue;
       }
       const possible = isPossibleProgramEntry(entry, policy);
@@ -4851,30 +4878,34 @@ function reportsProgramMembership(
   policy: ITtscProjectMembershipPolicy,
   filesystem: TtscTransformFilesystemOperations,
 ): boolean {
-  if (isPossibleProgramFileName(filename, policy)) {
-    // A name the program could admit. It still says nothing if it lies inside a
-    // directory the walk never descends into, because the digest cannot see
-    // there either and the tracker must not be the one side that reacts.
-    return !insideExcludedProjectDirectory(location, policy, true);
+  if (
+    !matchesProjectRootFile(location, policy, false) &&
+    !matchesProjectRootFile(location, policy, true)
+  ) {
+    return false;
   }
-  let directory: boolean;
   try {
-    directory = filesystem.lstat(location).isDirectory();
+    if (filesystem.lstat(location).isDirectory()) {
+      return (
+        matchesProjectRootFile(location, policy, true) &&
+        !insideExcludedProjectDirectory(location, policy, false)
+      );
+    }
   } catch {
-    // Gone again, or unreadable. Its name could not have been a program input,
-    // and a directory removed under this one reports its own contents leaving
-    // through the watch that was opened on it.
-    return false;
+    // Deleted file names still need classification below.
   }
-  if (!directory) {
-    return false;
+  if (isPossibleProgramFileName(filename, policy)) {
+    // A name the program could admit. It still says nothing if it lies inside a
+    // directory the walk never descends into, because the digest cannot see
+    // there either and the tracker must not be the one side that reacts.
+    return (
+      matchesProjectRootFile(location, policy, false) &&
+      !insideExcludedProjectDirectory(location, policy, true)
+    );
   }
-  // A directory counts, because it can hold sources and the tracker is not
-  // watching it yet, unless the configuration says the program does not contain
-  // it. Emptying and recreating an `outDir`, which is what `emptyOutDir` and
-  // `output.clean` do on every build, would otherwise void the generation once
-  // per build on every host that has no build boundary.
-  return !insideExcludedProjectDirectory(location, policy, false);
+  // Removed directories report their source removals through their own watch.
+  // A non-source file name cannot introduce program membership.
+  return false;
 }
 
 /** Record enough exact mutation evidence without retaining an event stream. */
@@ -5356,7 +5387,10 @@ export function isProjectWalkPath(
   // a graph input the compiler really read in neither snapshot: absent from
   // `inputHashes` because the walk skipped it, and absent from the out-of-walk
   // snapshot because this predicate claimed the walk covered it.
-  if (!isPossibleProgramFileName(path.basename(file), policy)) {
+  if (
+    !isPossibleProgramFileName(path.basename(file), policy) ||
+    !matchesProjectRootFile(file, policy, false)
+  ) {
     return false;
   }
   let current = resolvedRoot;

package/src/core/tsconfigPaths.ts

@@ -116,6 +116,16 @@ export function readTsconfigSourceSnapshot(
  * dropped from the walk entirely (samchon/ttsc#1307).
  */
 export interface ITtscProjectMembershipPolicy {
+  /** Absolute root-file specifications; absent means conservative discovery. */
+  rootFileSpecs?: Readonly<{
+    files: readonly string[];
+    include: readonly string[];
+    /**
+     * The requested root and its regular/native realpath spellings, without
+     * following child links. Native realpath expands Windows short names.
+     */
+    root?: Readonly<{ path: string; realpath: string; nativepath?: string }>;
+  }>;
   /**
    * Absolute directory exclusions separated by the configuration entry that
    * contributed them.
@@ -210,6 +220,48 @@ export function readProjectMembershipPolicy(
   // when it has gone stale. `findDeclaredValue` walks `extends` for each option
   // independently, and each walk records what it read.
   const sources = new Set<string>();
+  const fileSpec = (key: "files" | "include") =>
+    findDeclaredValue(
+      resolved,
+      (parsed) =>
+        Object.prototype.hasOwnProperty.call(parsed, key)
+          ? { value: (parsed as Record<string, unknown>)[key] }
+          : undefined,
+      new Set(),
+      sources,
+    );
+  const files = fileSpec("files");
+  const include = fileSpec("include");
+  const resolveSpecs = (
+    declared: ReturnType<typeof fileSpec>,
+  ): string[] | undefined => {
+    if (declared === null || declared.value.value == null) return undefined;
+    const value = declared.value.value;
+    if (
+      !Array.isArray(value) ||
+      !value.every((entry) => typeof entry === "string")
+    )
+      return undefined;
+    return value.map((entry) =>
+      absolutizePathsTarget(declared.baseDir, entry, path.dirname(resolved)),
+    );
+  };
+  const explicitFiles = resolveSpecs(files);
+  const includes = resolveSpecs(include);
+  const root = {
+    path: path.dirname(resolved),
+    realpath: resolveRealPath(path.dirname(resolved)),
+    nativepath: resolveNativeRootPath(path.dirname(resolved)),
+  };
+  // Missing/invalid specs keep the wide fallback. A files-only project has no
+  // implicit include, whereas include and files together form a union.
+  const rootFileSpecs =
+    includes !== undefined
+      ? { files: explicitFiles ?? [], include: includes, root }
+      : explicitFiles !== undefined &&
+          (include === null || include.value.value == null)
+        ? { files: explicitFiles, include: [], root }
+        : undefined;
   const flag = (key: string): boolean =>
     findDeclaredValue(
       resolved,
@@ -302,6 +354,7 @@ export function readProjectMembershipPolicy(
     }
   }
   return {
+    rootFileSpecs,
     directoryExclusionOrigins,
     excludedDirectories: flattenDirectoryExclusionOrigins(
       directoryExclusionOrigins,
@@ -367,6 +420,7 @@ export function mergeMembershipPolicyOverlay(
     }
   }
   return {
+    rootFileSpecs: policy.rootFileSpecs,
     directoryExclusionOrigins,
     excludedDirectories: flattenDirectoryExclusionOrigins(
       directoryExclusionOrigins,
@@ -866,10 +920,16 @@ function isRelativeSpecifier(specifier: string): boolean {
   );
 }
 
-/**
- * Resolve symlinks on `location`, returning the original path when
- * `realpathSync` fails (e.g. when the file does not exist).
- */
+/** Native watchers expand Windows short names that regular realpath retains. */
+function resolveNativeRootPath(location: string): string {
+  try {
+    return fs.realpathSync.native(location);
+  } catch {
+    return resolveRealPath(location);
+  }
+}
+
+/** Resolve symlinks, retaining the original spelling when the path is missing. */
 function resolveRealPath(location: string): string {
   try {
     return fs.realpathSync(location);