Patches2upstream no build artifacts

docs/packages/TypeScript_ESTree.mdx

@@ -367,3 +367,7 @@ const { ast, services } = parseAndGenerateServices(code, {
 
 If you encounter a bug with the parser that you want to investigate, you can turn on the debug logging via setting the environment variable: `DEBUG=typescript-eslint:*`.
 I.e. in this repo you can run: `DEBUG=typescript-eslint:* yarn lint`.
+
+This will include TypeScript server logs.
+To turn off these logs, include `-typescript-eslint:typescript-estree:tsserver:*` when setting the environment variable.
+I.e. for this repo change to: `DEBUG='typescript-eslint:*,-typescript-eslint:typescript-estree:tsserver:*' yarn lint`.

packages/types/src/parser-options.ts

@@ -44,12 +44,22 @@ interface ProjectServiceOptions {
    * Globs of files to allow running with the default project compiler options
    * despite not being matched by the project service.
    */
-  allowDefaultProject?: string[];
+  allowDefaultProject?: string[] | undefined;
 
   /**
    * Path to a TSConfig to use instead of TypeScript's default project configuration.
    */
-  defaultProject?: string;
+  defaultProject?: string | undefined | null;
+
+  /**
+   * Maximum number of files to keep open with the project service.
+   */
+  maximumOpenFiles?: number;
+
+  /**
+   * Send changes to files as diffs instead of replacing the entire files.
+   */
+  incremental?: boolean;
 
   /**
    * The maximum number of files {@link allowDefaultProject} may match.

packages/typescript-estree/package.json

@@ -57,14 +57,17 @@
     "@typescript-eslint/types": "7.13.0",
     "@typescript-eslint/visitor-keys": "7.13.0",
     "debug": "^4.3.4",
+    "diff": "^5.2.0",
     "globby": "^11.1.0",
     "is-glob": "^4.0.3",
+    "lru-cache": "^10.2.2",
     "minimatch": "^9.0.4",
     "semver": "^7.6.0",
     "ts-api-utils": "^1.3.0"
   },
   "devDependencies": {
     "@jest/types": "29.6.3",
+    "@types/diff": "^5.2.1",
     "glob": "*",
     "jest": "29.7.0",
     "prettier": "^3.2.5",

packages/typescript-estree/src/create-program/createProjectService.ts

@@ -1,114 +1,145 @@
 /* eslint-disable @typescript-eslint/no-empty-function -- for TypeScript APIs*/
-import os from 'node:os';
+import path from 'node:path';
 
+import debug from 'debug';
 import type * as ts from 'typescript/lib/tsserverlibrary';
 
 import type { ProjectServiceOptions } from '../parser-options';
+import { getParsedConfigFile } from './getParsedConfigFile';
+import {
+  saveDirectoryWatchCallback,
+  saveFileWatchCallback,
+} from './getWatchesForProjectService';
 import { validateDefaultProjectForFilesGlob } from './validateDefaultProjectForFilesGlob';
 
-const DEFAULT_PROJECT_MATCHED_FILES_THRESHOLD = 8;
+const log = debug('typescript-eslint:typescript-estree:createProjectService');
+const logTsserverErr = debug(
+  'typescript-eslint:typescript-estree:tsserver:err',
+);
+const logTsserverInfo = debug(
+  'typescript-eslint:typescript-estree:tsserver:info',
+);
+const logTsserverPerf = debug(
+  'typescript-eslint:typescript-estree:tsserver:perf',
+);
+const logTsserverEvent = debug(
+  'typescript-eslint:typescript-estree:tsserver:event',
+);
 
 const doNothing = (): void => {};
 
-const createStubFileWatcher = (): ts.FileWatcher => ({
-  close: doNothing,
-});
-
 export type TypeScriptProjectService = ts.server.ProjectService;
 
 export interface ProjectServiceSettings {
   allowDefaultProject: string[] | undefined;
   maximumDefaultProjectFileMatchCount: number;
   service: TypeScriptProjectService;
+  maximumOpenFiles: number;
+  incremental: boolean;
 }
 
 export function createProjectService(
-  optionsRaw: boolean | ProjectServiceOptions | undefined,
+  options: Required<ProjectServiceOptions>,
   jsDocParsingMode: ts.JSDocParsingMode | undefined,
 ): ProjectServiceSettings {
-  const options = typeof optionsRaw === 'object' ? optionsRaw : {};
   validateDefaultProjectForFilesGlob(options);
 
   // We import this lazily to avoid its cost for users who don't use the service
   // TODO: Once we drop support for TS<5.3 we can import from "typescript" directly
   // eslint-disable-next-line @typescript-eslint/no-require-imports
   const tsserver = require('typescript/lib/tsserverlibrary') as typeof ts;
 
-  // TODO: see getWatchProgramsForProjects
-  // We don't watch the disk, we just refer to these when ESLint calls us
-  // there's a whole separate update pass in maybeInvalidateProgram at the bottom of getWatchProgramsForProjects
-  // (this "goes nuclear on TypeScript")
   const system: ts.server.ServerHost = {
     ...tsserver.sys,
     clearImmediate,
     clearTimeout,
     setImmediate,
     setTimeout,
-    watchDirectory: createStubFileWatcher,
-    watchFile: createStubFileWatcher,
+    watchDirectory: saveDirectoryWatchCallback,
+    watchFile: saveFileWatchCallback,
   };
 
+  const logger: ts.server.Logger = {
+    close: doNothing,
+    endGroup: doNothing,
+    getLogFileName: (): undefined => undefined,
+    // The debug library doesn't use levels without creating a namespace for each.
+    // Log levels are not passed to the writer so we wouldn't be able to forward
+    // to a respective namespace.  Supporting would require an additional flag for
+    // granular control.  Defaulting to all levels for now.
+    hasLevel: (): boolean => true,
+    info(s) {
+      this.msg(s, tsserver.server.Msg.Info);
+    },
+    loggingEnabled: (): boolean =>
+      // if none of the debug namespaces are enabled, then don't enable logging in tsserver
+      logTsserverInfo.enabled ||
+      logTsserverErr.enabled ||
+      logTsserverPerf.enabled,
+    msg: (s, type) => {
+      switch (type) {
+        case tsserver.server.Msg.Err:
+          logTsserverErr(s);
+          break;
+        case tsserver.server.Msg.Perf:
+          logTsserverPerf(s);
+          break;
+        default:
+          logTsserverInfo(s);
+      }
+    },
+    perftrc(s) {
+      this.msg(s, tsserver.server.Msg.Perf);
+    },
+    startGroup: doNothing,
+  };
+
+  log('Creating project service with: %o', options);
+
   const service = new tsserver.server.ProjectService({
     host: system,
     cancellationToken: { isCancellationRequested: (): boolean => false },
     useSingleInferredProject: false,
     useInferredProjectPerProjectRoot: false,
-    logger: {
-      close: doNothing,
-      endGroup: doNothing,
-      getLogFileName: (): undefined => undefined,
-      hasLevel: (): boolean => false,
-      info: doNothing,
-      loggingEnabled: (): boolean => false,
-      msg: doNothing,
-      perftrc: doNothing,
-      startGroup: doNothing,
-    },
+    logger,
+    eventHandler: logTsserverEvent.enabled
+      ? (e): void => {
+          logTsserverEvent(e);
+        }
+      : undefined,
     session: undefined,
+    canUseWatchEvents: true,
     jsDocParsingMode,
   });
 
   if (options.defaultProject) {
-    let configRead;
-
+    log('Enabling default project: %s', options.defaultProject);
     try {
-      configRead = tsserver.readConfigFile(
+      const configFile = getParsedConfigFile(
         options.defaultProject,
-        system.readFile,
+        path.dirname(options.defaultProject),
+      );
+      service.setCompilerOptionsForInferredProjects(
+        // NOTE: The inferred projects API is not intended for source files when a tsconfig
+        // exists.  There is no API that generates an InferredProjectCompilerOptions suggesting
+        // it is meant for hard coded options passed in.  Hard casting as a work around.
+        // See https://github.com/microsoft/TypeScript/blob/27bcd4cb5a98bce46c9cdd749752703ead021a4b/src/server/protocol.ts#L1904
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-explicit-any
+        configFile.options as ts.server.protocol.InferredProjectCompilerOptions,
       );
     } catch (error) {
       throw new Error(
         `Could not parse default project '${options.defaultProject}': ${(error as Error).message}`,
       );
     }
-
-    if (configRead.error) {
-      throw new Error(
-        `Could not read default project '${options.defaultProject}': ${tsserver.formatDiagnostic(
-          configRead.error,
-          {
-            getCurrentDirectory: system.getCurrentDirectory,
-            getCanonicalFileName: fileName => fileName,
-            getNewLine: () => os.EOL,
-          },
-        )}`,
-      );
-    }
-
-    service.setCompilerOptionsForInferredProjects(
-      (
-        configRead.config as {
-          compilerOptions: ts.server.protocol.InferredProjectCompilerOptions;
-        }
-      ).compilerOptions,
-    );
   }
 
   return {
     allowDefaultProject: options.allowDefaultProject,
+    maximumOpenFiles: options.maximumOpenFiles,
+    incremental: options.incremental,
     maximumDefaultProjectFileMatchCount:
-      options.maximumDefaultProjectFileMatchCount_THIS_WILL_SLOW_DOWN_LINTING ??
-      DEFAULT_PROJECT_MATCHED_FILES_THRESHOLD,
+      options.maximumDefaultProjectFileMatchCount_THIS_WILL_SLOW_DOWN_LINTING,
     service,
   };
 }

packages/typescript-estree/src/create-program/getParsedConfigFile.ts

@@ -0,0 +1,64 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import type * as ts from 'typescript/lib/tsserverlibrary';
+
+import { CORE_COMPILER_OPTIONS } from './shared';
+
+/**
+ * Utility offered by parser to help consumers parse a config file.
+ *
+ * @param configFile the path to the tsconfig.json file, relative to `projectDirectory`
+ * @param projectDirectory the project directory to use as the CWD, defaults to `process.cwd()`
+ */
+function getParsedConfigFile(
+  configFile: string,
+  projectDirectory?: string,
+): ts.ParsedCommandLine {
+  // We import this lazily to avoid its cost for users who don't use the service
+  // TODO: Once we drop support for TS<5.3 we can import from "typescript" directly
+  // eslint-disable-next-line @typescript-eslint/no-require-imports
+  const tsserver = require('typescript/lib/tsserverlibrary') as typeof ts;
+
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+  if (tsserver.sys === undefined) {
+    throw new Error(
+      '`createProgramFromConfigFile` is only supported in a Node-like environment.',
+    );
+  }
+
+  const parsed = tsserver.getParsedCommandLineOfConfigFile(
+    configFile,
+    CORE_COMPILER_OPTIONS,
+    {
+      onUnRecoverableConfigFileDiagnostic: diag => {
+        throw new Error(formatDiagnostics([diag])); // ensures that `parsed` is defined.
+      },
+      fileExists: fs.existsSync,
+      getCurrentDirectory: () =>
+        (projectDirectory && path.resolve(projectDirectory)) || process.cwd(),
+      readDirectory: tsserver.sys.readDirectory,
+      readFile: file => fs.readFileSync(file, 'utf-8'),
+      useCaseSensitiveFileNames: tsserver.sys.useCaseSensitiveFileNames,
+    },
+  );
+
+  // parsed is not undefined, since we throw on failure.
+  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+  const result = parsed!;
+  if (result.errors.length) {
+    throw new Error(formatDiagnostics(result.errors));
+  }
+
+  return result;
+
+  // scoped to parent function to use lazy typescript import
+  function formatDiagnostics(diagnostics: ts.Diagnostic[]): string | undefined {
+    return tsserver.formatDiagnostics(diagnostics, {
+      getCanonicalFileName: f => f,
+      getCurrentDirectory: process.cwd,
+      getNewLine: () => '\n',
+    });
+  }
+}
+
+export { getParsedConfigFile };