@ttsc/lint 0.23.0 → 0.25.0

package/linthost/host.go

@@ -42,6 +42,15 @@ type program struct {
   checker      *shimchecker.Checker
   identity     publicrule.ProjectIdentity
   projectCycle *projectCycle
+  // projectRoots memoizes projectSourceFileNames, which resolves every
+  // selected file's path and therefore costs filesystem work. The tsconfig
+  // selection cannot change while one program is loaded — a config edit or a
+  // new or removed file forces a full reload upstream rather than an
+  // applyChange — while every read and every write consults the set at least
+  // once per cycle, and a fix or format cascade repeats that per pass. Filled
+  // lazily under the same single-threaded assumption projectCycle already
+  // makes, and read-only to its callers.
+  projectRoots map[string]struct{}
 }
 
 type loadProgramOptions struct {
@@ -274,11 +283,38 @@ func (p *program) runProjectCycle(engine *Engine) *projectCycle {
   return p.projectCycle
 }
 
+// runLintCycle walks everything the invocation reads: the project's own sources
+// and the TypeScript it imported. Every caller here reports its findings, so a
+// source the type-check pass read must be able to produce one.
 func (p *program) runLintCycle(engine *Engine) []*Finding {
+  return p.runCycleOver(engine, p.userSourceFiles())
+}
+
+// runWriteScopedCycle walks the project's own sources alone. It serves the
+// commands that edit files and report nothing: `format` and the LSP document
+// fix and format verbs.
+//
+// Such a command must not rewrite a sibling package it merely imports, and it
+// prints no diagnostic, so a finding outside the project has nowhere to go.
+// Reading wider would spend a full walk, once per cascade pass, on findings the
+// command discards. Scope is enforced by what these commands read rather than
+// by filtering afterwards, which leaves projectWritableFindings to `fix` alone.
+func (p *program) runWriteScopedCycle(engine *Engine) []*Finding {
+  return p.runCycleOver(engine, p.projectSourceFiles())
+}
+
+// runCycleOver evaluates the project rules and the file rules over one file set,
+// memoizing the project cycle on the program so a second verb against the same
+// program does not re-evaluate a rule. The caller owns the scope decision.
+//
+// That memo makes the scope a property of the program, not of the call: the
+// first cycle fixes the population every later verb observes. One loaded
+// program therefore serves one scope, and a caller must not ask the same
+// program for both a lint cycle and a write-scoped one.
+func (p *program) runCycleOver(engine *Engine, files []*shimast.SourceFile) []*Finding {
   if p == nil || engine == nil {
     return nil
   }
-  files := p.userSourceFiles()
   if p.projectCycle == nil {
     p.projectCycle = engine.evaluateProject(p.identity, files, p.checker)
   }
@@ -348,19 +384,59 @@ func (p *program) applyChange(absPath string) bool {
   return reused
 }
 
-// userSourceFiles returns the tsconfig-selected source files the lint engine
-// owns. The tsconfig file list is the boundary: imported libraries, generated
-// output, and JSON modules may still appear in Program.SourceFiles(), but lint
-// and format should not walk them unless the project selected them as TS/JS
-// source roots.
+// userSourceFiles returns the source files the lint engine reads for one cycle:
+// the tsconfig-selected TS/JS roots plus every TypeScript source the Program
+// pulled in through an import.
+//
+// The tsconfig file list alone is not the boundary. `ttsc` type-checks a
+// first-party sibling workspace package that resolves to its own `src`, so a
+// reporting pass restricted to the file list would hold a second, narrower view
+// of the single Program the invocation loaded — the file is checked but never
+// linted, and never reaches a project rule's ctx.Sources (samchon/ttsc#1065).
+// A consumer cannot close that gap from configuration either: adding the
+// sibling to `include` also changes what the project emits.
+//
+// The widening admits authored TypeScript only — `.ts`, `.tsx`, `.mts`, `.cts`
+// that are not declaration files. Everything else stays selection-driven:
+//   - a declaration file is typings rather than authored source, and the bundled
+//     `lib.*.d.ts` set plus every published package's `.d.ts` reach
+//     Program.SourceFiles() as well;
+//   - JavaScript enters the Program only under `allowJs`, where the project's own
+//     file list already selects the JS it owns;
+//   - a JSON module carries no lint source at all.
+//
+// A project that selects any of those explicitly keeps them, exactly as before.
+// A published dependency reaches the Program through its typings, so its own
+// `.ts` sources stay out without a dependency-shaped rule here.
 func (p *program) userSourceFiles() []*shimast.SourceFile {
-  roots := p.userSourceFileNames()
+  roots := p.projectSourceFileNames()
   out := make([]*shimast.SourceFile, 0)
   for _, f := range p.tsProgram.SourceFiles() {
     if f == nil {
       continue
     }
-    if _, ok := roots[canonicalProjectPath(p.cwd, f.FileName())]; !ok {
+    if p.selectedByProject(roots, f.FileName()) {
+      out = append(out, f)
+      continue
+    }
+    if isImportedLintSourceFile(f) {
+      out = append(out, f)
+    }
+  }
+  return out
+}
+
+// projectSourceFiles returns the Program's copy of the files the tsconfig itself
+// selected — the project's own sources, the set `format` walks and the set any
+// lint write stays inside.
+func (p *program) projectSourceFiles() []*shimast.SourceFile {
+  roots := p.projectSourceFileNames()
+  out := make([]*shimast.SourceFile, 0, len(roots))
+  for _, f := range p.tsProgram.SourceFiles() {
+    if f == nil {
+      continue
+    }
+    if !p.selectedByProject(roots, f.FileName()) {
       continue
     }
     out = append(out, f)
@@ -368,15 +444,88 @@ func (p *program) userSourceFiles() []*shimast.SourceFile {
   return out
 }
 
-func (p *program) userSourceFileNames() map[string]struct{} {
+// projectSourceFileNames returns the canonical paths of the TS/JS files the
+// tsconfig itself selected, indexed under both the configured spelling and the
+// resolved one.
+//
+// This is the narrow half of the boundary above. `format` reads nothing else at
+// all, and `fix` reads wider but writes only here, because a project must not
+// rewrite a sibling package's sources merely because it imports them. See
+// projectWritableFindings.
+//
+// Both spellings are indexed because a project can be reached through a
+// junction, a symlink, or a Windows 8.3 short name, and the Program need not
+// report a file under the spelling the config used. Before the read scope
+// widened, an alias mismatch merely dropped the file from every pass. Now it
+// would leave the file readable and unwritable, turning a fixable diagnostic
+// into one `fix` refuses to touch, so ownership resolves the alias.
+func (p *program) projectSourceFileNames() map[string]struct{} {
+  if p == nil {
+    return map[string]struct{}{}
+  }
+  if p.projectRoots != nil {
+    return p.projectRoots
+  }
   out := make(map[string]struct{})
-  if p == nil || p.parsed == nil || p.parsed.ParsedConfig == nil {
-    return out
+  if p.parsed != nil && p.parsed.ParsedConfig != nil {
+    for _, fileName := range p.parsed.ParsedConfig.FileNames {
+      if !isLintSourceFileName(fileName) {
+        continue
+      }
+      absolute := absoluteProjectPath(p.cwd, fileName)
+      out[canonicalProjectPath(p.cwd, absolute)] = struct{}{}
+      out[canonicalProjectPath(p.cwd, realProjectPath(absolute))] = struct{}{}
+    }
+  }
+  p.projectRoots = out
+  return out
+}
+
+// selectedByProject reports whether the tsconfig selected fileName, resolving
+// the path only when its own spelling misses.
+//
+// Indexing both spellings above already catches the ordinary link, so this
+// fallback exists for a Program spelling that matches neither, such as a
+// Windows 8.3 short name. It costs one resolution per file the config did not
+// select, paid by the imported set on every cycle, against the rule walk those
+// same files are about to receive.
+func (p *program) selectedByProject(
+  roots map[string]struct{},
+  fileName string,
+) bool {
+  if p == nil || len(roots) == 0 {
+    return false
   }
-  for _, fileName := range p.parsed.ParsedConfig.FileNames {
-    if isLintSourceFileName(fileName) {
-      out[canonicalProjectPath(p.cwd, fileName)] = struct{}{}
+  if _, ok := roots[canonicalProjectPath(p.cwd, fileName)]; ok {
+    return true
+  }
+  resolved := realProjectPath(absoluteProjectPath(p.cwd, fileName))
+  _, ok := roots[canonicalProjectPath(p.cwd, resolved)]
+  return ok
+}
+
+// projectWritableFindings keeps the findings whose file this project may write:
+// the ones sitting in a tsconfig-selected source, dropping every edit aimed at a
+// source the Program reached only through an import.
+//
+// This is `fix`'s guard alone, because `fix` is the one command that must read
+// wider than it writes: it prints the diagnostics that survive the cascade, so
+// an imported source has to reach its report while its edit must not reach
+// disk. The package that owns the file fixes it from its own run, under its own
+// config. Commands that only write walk the narrow set to begin with. A finding
+// without a source file (a project rule's detached report) never reaches disk
+// either and is dropped with them.
+func (p *program) projectWritableFindings(findings []*Finding) []*Finding {
+  roots := p.projectSourceFileNames()
+  out := make([]*Finding, 0, len(findings))
+  for _, finding := range findings {
+    if finding == nil || finding.File == nil {
+      continue
     }
+    if !p.selectedByProject(roots, finding.File.FileName()) {
+      continue
+    }
+    out = append(out, finding)
   }
   return out
 }
@@ -388,6 +537,18 @@ func canonicalProjectPath(cwd, fileName string) string {
   return filepath.ToSlash(filepath.Clean(fileName))
 }
 
+// isImportedLintSourceFile reports whether a Program source file the tsconfig
+// did not select is authored TypeScript the lint pass must still read.
+func isImportedLintSourceFile(file *shimast.SourceFile) bool {
+  if file == nil || file.IsDeclarationFile {
+    return false
+  }
+  return isTypeScriptSourceFileName(file.FileName())
+}
+
+// isLintSourceFileName reports whether a tsconfig-selected file is a lint/format
+// source root. The project's own selection governs here, so both TypeScript and
+// JavaScript qualify: a project that lists `.js` under `allowJs` owns it.
 func isLintSourceFileName(fileName string) bool {
   switch strings.ToLower(filepath.Ext(fileName)) {
   case ".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs":
@@ -397,6 +558,18 @@ func isLintSourceFileName(fileName string) bool {
   }
 }
 
+// isTypeScriptSourceFileName reports whether a path names TypeScript source.
+// `.d.ts` shares the `.ts` extension, so callers pair this with the source
+// file's IsDeclarationFile flag rather than reading the suffix twice.
+func isTypeScriptSourceFileName(fileName string) bool {
+  switch strings.ToLower(filepath.Ext(fileName)) {
+  case ".ts", ".tsx", ".mts", ".cts":
+    return true
+  default:
+    return false
+  }
+}
+
 // programDiagnostics returns the bind + semantic diagnostics for the
 // loaded program. Same surface tsgo's CLI prints when you run a regular
 // `tsgo --noEmit`.

package/linthost/lsp.go

@@ -981,7 +981,11 @@ func lspWorkspaceEditForSeededCommand(
       prog.close()
       return nil, 0
     }
-    findings := filterFindingsForPath(prog.runLintCycle(engine), tempTarget)
+    // This command edits a document, so it walks the project's own sources the
+    // way `format` does. Reading the imported TypeScript the lint cycle covers
+    // would widen nothing here: the edit is bounded to one target below, and a
+    // read-scope widening must not open a write the project never had.
+    findings := filterFindingsForPath(prog.runWriteScopedCycle(engine), tempTarget)
     prog.close()
     if opts.command == commandFormatDocument {
       findings = filterFormatFindings(findings)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ttsc/lint",
-  "version": "0.23.0",
+  "version": "0.25.0",
   "description": "Reference ttsc plugin: ESLint-style lint rules over the TypeScript-Go Program used by the type-check pass.",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -37,7 +37,7 @@
     "@types/node": "^25.3.0",
     "rimraf": "^6.1.2",
     "typescript": "^7.0.2",
-    "ttsc": "0.23.0"
+    "ttsc": "0.25.0"
   },
   "repository": {
     "type": "git",

package/rule/project.go

@@ -170,7 +170,18 @@ type ProjectReporter interface {
 }
 
 // ProjectContext contains the immutable inputs for one project-rule check.
-// Sources is a defensive copy of the Program's tsconfig-selected user sources.
+//
+// Sources is a defensive copy of the user sources the host read for this cycle:
+// the project's own tsconfig-selected files plus every TypeScript source the
+// Program pulled in through an import, minus globally ignored paths. A rule
+// that declares a population by glob therefore sees a first-party sibling
+// workspace package the same way the type-check pass does, instead of an empty
+// population that would silently report full coverage.
+//
+// A format run is the exception. It writes files and reports nothing, so it
+// walks the project's own file list alone and a rule evaluated there receives
+// that narrower population. Draw a conclusion that must hold across the
+// workspace from a lint or check run.
 type ProjectContext struct {
   Identity ProjectIdentity
   Sources  []*shimast.SourceFile

package/src/index.ts

@@ -8,9 +8,7 @@ import path from "node:path";
 import { pathToFileURL } from "node:url";
 
 import {
-  CONFIG_EVALUATOR_PROCESS_OPTIONS,
-  CONFIG_EVALUATOR_STATUS_FD,
-  configEvaluatorBoundaryEnvironment,
+  configEvaluatorFailureReason,
   configEvaluatorProcessFailure,
 } from "./internal/configEvaluatorFailure";
 import type { ITtscLintPlugin, ITtscLintPluginConfig } from "./structures";
@@ -630,33 +628,68 @@ const hooks = registerHooks({
   },
 });
 
-try {
-  const importedConfig = configLocation.toLowerCase().endsWith(".json")
-    ? JSON.parse(fs.readFileSync(configLocation, "utf8").replace(/^\uFEFF/, ""))
-    : await import(configUrl);
-  const current = await resolveConfig(importedConfig, true);
-  const pluginMaps = collectPluginObjects(current);
-  const entries: Array<{ namespace: string; source: string }> = [];
-  for (const map of pluginMaps) {
-    for (const [namespace, value] of Object.entries(map)) {
-      const source = extractPluginSource(value);
-      if (source === undefined || source.length === 0) {
-        throw new Error(
-          \`contributor \${JSON.stringify(namespace)} must resolve to an object with a non-empty "source" string\`,
-        );
+// Wrapped and settled explicitly rather than written as a top-level await.
+// The loader tsconfig's "module" now follows the config's own package, and
+// TS1378 rejects top-level await under a CommonJS module option however this
+// .mts file emits. The trailing catch is what a top-level await gave for
+// free: without it a throw from the finally would leave the promise
+// unsettled instead of failing the load.
+(async () => {
+  try {
+    const importedConfig = configLocation.toLowerCase().endsWith(".json")
+      ? JSON.parse(fs.readFileSync(configLocation, "utf8").replace(/^\uFEFF/, ""))
+      : await import(configUrl);
+    const current = await resolveConfig(importedConfig, true);
+    const pluginMaps = collectPluginObjects(current);
+    const entries: Array<{ namespace: string; source: string }> = [];
+    for (const map of pluginMaps) {
+      for (const [namespace, value] of Object.entries(map)) {
+        const source = extractPluginSource(value);
+        if (source === undefined || source.length === 0) {
+          throw new Error(
+            \`contributor \${JSON.stringify(namespace)} must resolve to an object with a non-empty "source" string\`,
+          );
+        }
+        entries.push({ namespace, source });
       }
-      entries.push({ namespace, source });
     }
+    fs.writeFileSync(outputPath, JSON.stringify({
+      dependencies: finalizeDependencies(),
+      entries,
+    }), "utf8");
+  } catch (error) {
+    reportLoaderFailure(error);
+  } finally {
+    hooks.deregister();
   }
-  fs.writeFileSync(outputPath, JSON.stringify({
-    dependencies: finalizeDependencies(),
-    entries,
-  }), "utf8");
-} catch (error) {
-  process.stderr.write(error instanceof Error && error.stack ? error.stack : String(error));
-  process.exit(1);
-} finally {
-  hooks.deregister();
+})().catch((error) => {
+  // Reached only when the finally above throws: the catch already ends the
+  // process, so this is the deregistration's own failure, not the config's.
+  reportLoaderFailure(error);
+});
+
+// reportLoaderFailure ends this loader on an error it can name, on both of the
+// channels the parent uses.
+//
+// The stack is for a reader and streams to stderr as it is written. The reason
+// is a fact about the user's config that a caller has to act on, so it travels
+// as data through the result file the parent already reads. Only a well-formed
+// envelope is honoured there, so a partially written or unrelated file leaves
+// the process status to speak for itself.
+function reportLoaderFailure(error: unknown): never {
+  // The trailing newline ends the stack as a line of its own. Without it the
+  // parent's own message, written to this same stream, starts mid-line.
+  process.stderr.write((error instanceof Error && error.stack ? error.stack : String(error)) + "\\n");
+  try {
+    fs.writeFileSync(
+      outputPath,
+      JSON.stringify({ __ttscLoaderError: error instanceof Error ? error.message : String(error) }),
+      "utf8",
+    );
+  } catch {
+    // A reason that cannot be written leaves the exit status as the report.
+  }
+  return process.exit(1);
 }
 
 function isObject(value: unknown): value is Record<string, unknown> {
@@ -1702,7 +1735,13 @@ function evaluateTtsxConfigPlugins(
             allowImportingTsExtensions: true,
             allowJs: true,
             checkJs: false,
-            module: "ESNext",
+            // The config is a Node module, so Node's rule decides its format:
+            // the nearest `package.json` `type` above it. Hardcoding one answer
+            // ran every ambiguous `.ts` config as ESM and broke `__dirname` in
+            // an ordinary CommonJS package (#1068). `moduleResolution` stays
+            // `bundler`, which tsgo accepts for both kinds, so extensionless
+            // relative imports keep resolving either way.
+            module: configModuleOption(configPath),
             moduleResolution: "bundler",
             noImplicitAny: false,
             outDir: path.join(tempDir, "out").replace(/\\/g, "/"),
@@ -1711,6 +1750,12 @@ function evaluateTtsxConfigPlugins(
             skipLibCheck: true,
             strict: false,
             target: "ES2022",
+            // TypeScript 7 includes no ambient type package unless `types` asks
+            // for it, and this Program extends nothing, so without the wildcard
+            // a config could not name a single Node global (#1068). The loader
+            // directory links the config's nearest `node_modules`, so the
+            // default `typeRoots` walk finds exactly what the project installed.
+            types: ["*"],
           },
           files: [
             loaderPath.replace(/\\/g, "/"),
@@ -1749,28 +1794,29 @@ function evaluateTtsxConfigPlugins(
     }
     const env = {
       ...nodeConfigLoaderEnv(configPath),
-      ...configEvaluatorBoundaryEnvironment(),
     };
     const command = ttsxThroughNodeIfNeeded(ttsxBinary);
     const result = spawnSync(command.binary, [...command.prefix, ...args], {
       cwd: tempDir,
       env,
-      encoding: "utf8",
-      ...CONFIG_EVALUATOR_PROCESS_OPTIONS,
-      stdio: [
-        "ignore",
-        "pipe",
-        "pipe",
-        ...Array.from(
-          { length: CONFIG_EVALUATOR_STATUS_FD - 2 },
-          () => "pipe" as const,
-        ),
-      ],
+      // Both child streams are human output, and they go straight to this
+      // process's stderr as they are written. Nothing is collected here: the
+      // parent's stdout is reserved for compiler JSON and LSP frames, and
+      // buffering the child only to replay it afterwards is what forced an
+      // invented output ceiling and made a long evaluation print nothing at all.
+      stdio: ["ignore", 2, 2],
       windowsHide: true,
     });
-    forwardConfigEvaluatorStreams(result.stdout, result.stderr);
     const processFailure = configEvaluatorProcessFailure(result, configPath);
-    if (processFailure) throw processFailure;
+    if (processFailure) {
+      // The evaluator's stack already reached the user's stderr as it ran. What
+      // it could not put there is a reason a caller can act on, so that arrives
+      // through the result file instead.
+      const reason = configEvaluatorFailureReason(outputPath);
+      throw reason === ""
+        ? processFailure
+        : new Error(`${processFailure.message}\n${reason}`);
+    }
     let payload: {
       dependencies?: ConfigDependencyFingerprint[];
       entries?: ConfigPluginEntry[];
@@ -1841,20 +1887,10 @@ function evaluateTtsxConfigPlugins(
     }
     return { dependencies, entries };
   } finally {
-    fs.rmSync(tempDir, { recursive: true, force: true });
+    removeEvaluationTempDir(tempDir);
   }
 }
 
-function forwardConfigEvaluatorStreams(
-  stdout: string | null | undefined,
-  stderr: string | null | undefined,
-): void {
-  // Both child streams are human output. Parent stdout is reserved for compiler
-  // JSON or LSP frames, so even a user console.log is redirected.
-  if (stdout) process.stderr.write(stdout);
-  if (stderr) process.stderr.write(stderr);
-}
-
 // ────────────────────────────────────────────────────────────────────────────
 // Config cache (shared with the Go sidecar — packages/lint/linthost/config.go)
 // ────────────────────────────────────────────────────────────────────────────
@@ -2268,6 +2304,64 @@ function findNearestNodeModules(start: string): string | undefined {
   }
 }
 
+/**
+ * The loader tsconfig's `module` for a given config file: the module kind Node
+ * would give the file itself.
+ *
+ * An explicit `.cts`/`.cjs` or `.mts`/`.mjs` extension already decides the emit
+ * format on its own, so those keep the ES-module setting and let the extension
+ * win — the same precedence tsgo applies. Everything ambiguous walks up for the
+ * nearest `package.json` `type`, exactly as Node does when it loads the file.
+ */
+function configModuleOption(configPath: string): string {
+  const extension = path.extname(configPath).toLowerCase();
+  if (extension !== ".ts" && extension !== ".tsx" && extension !== ".js") {
+    return "ESNext";
+  }
+  return nearestPackageType(configPath) === "commonjs" ? "CommonJS" : "ESNext";
+}
+
+/**
+ * Nearest `package.json` `"type"` at or above `configPath`, mirroring Node's
+ * package-scope lookup: the walk stops at the **first** manifest it finds, and
+ * a manifest that declares no `"type"` means CommonJS rather than a reason to
+ * keep climbing. Reaching the filesystem root without any manifest also means
+ * CommonJS.
+ */
+function nearestPackageType(configPath: string): "commonjs" | "module" {
+  let dir = path.dirname(path.resolve(configPath));
+  for (;;) {
+    // One read rather than a stat-then-read: an unreadable entry and a missing
+    // one are the same answer here — keep walking — and the Go loaders resolve
+    // it the same way, so the four implementations of this rule cannot drift.
+    let raw: string | undefined;
+    try {
+      raw = fs.readFileSync(path.join(dir, "package.json"), "utf8");
+    } catch {
+      raw = undefined;
+    }
+    if (raw !== undefined) {
+      try {
+        const manifest: unknown = JSON.parse(raw);
+        const type =
+          typeof manifest === "object" && manifest !== null
+            ? (manifest as { type?: unknown }).type
+            : undefined;
+        return type === "module" ? "module" : "commonjs";
+      } catch {
+        // A manifest that does not parse still bounds the package scope; Node
+        // refuses to look past it, and CommonJS is the format it defaults to.
+        return "commonjs";
+      }
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) {
+      return "commonjs";
+    }
+    dir = parent;
+  }
+}
+
 function linkNearestNodeModules(tempDir: string, sourceDir: string): void {
   const nodeModules = findNearestNodeModules(sourceDir);
   if (!nodeModules) return;
@@ -2400,3 +2494,19 @@ function ttsxThroughNodeIfNeeded(binary: string): {
   }
   return { binary, prefix: [] };
 }
+
+/**
+ * Remove an evaluation temp directory without letting cleanup replace a result.
+ *
+ * This runs from a `finally`, so a throw here would surface instead of the
+ * evaluation's own outcome — and on Windows a grandchild that inherited a
+ * handle, or a scanner holding the file, can make removal fail. Leaving bytes
+ * in the system temp directory is by far the lesser outcome.
+ */
+function removeEvaluationTempDir(directory: string): void {
+  try {
+    fs.rmSync(directory, { force: true, recursive: true });
+  } catch {
+    // Best effort.
+  }
+}