feat(typescript-estree): add EXPERIMENTAL_useProjectService option to use TypeScript project service

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

@@ -28,10 +28,12 @@ const DEFAULT_EXTRA_FILE_EXTENSIONS = [
  */
 function createProjectProgram(
   parseSettings: ParseSettings,
+  programsForProjects: readonly ts.Program[],
 ): ASTAndDefiniteProgram | undefined {
   log('Creating project program for: %s', parseSettings.filePath);
 
-  const programsForProjects = getWatchProgramsForProjects(parseSettings);
+  // const programsForProjects = getWatchProgramsForProjects(parseSettings);
+  // const programsForProjects = createPrograms(parseSettings);
   const astAndProgram = firstDefined(programsForProjects, currentProgram =>
     getAstFromProgram(currentProgram, parseSettings),
   );

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

@@ -0,0 +1,70 @@
+import * as ts from 'typescript';
+import * as tsserver from 'typescript/lib/tsserverlibrary';
+
+export function createProjectService() {
+  const compilerOptions = { /* todo */ strict: true };
+  const compilerHost = tsserver.createCompilerHost(compilerOptions, true);
+
+  // 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 watchFile = (
+    path: string,
+    callback: ts.FileWatcherCallback,
+  ): ts.FileWatcher => {
+    // todo (or just ... stub out?)
+    return { close() {} };
+  };
+
+  const watchDirectory = (
+    path: string,
+    callback: ts.DirectoryWatcherCallback,
+  ) => {
+    // todo (or just ... stub out?)
+    return { close() {} };
+  };
+
+  const system = {
+    ...ts.sys,
+    watchFile,
+    watchDirectory,
+    setTimeout,
+    clearTimeout,
+    setImmediate,
+    clearImmediate,
+  };
+
+  const projectService = new tsserver.server.ProjectService({
+    host: system,
+
+    // todo: look into these
+    cancellationToken: { isCancellationRequested: () => false },
+    useSingleInferredProject: false, // ???
+    useInferredProjectPerProjectRoot: false, // ???
+    typingsInstaller: {
+      attach: () => {},
+      enqueueInstallTypingsRequest: () => {},
+      installPackage: async (): Promise<never> => {
+        throw new Error('pls no');
+      },
+      isKnownTypesPackageName: () => false,
+      onProjectClosed: () => {},
+      globalTypingsCacheLocation: '',
+    },
+    logger: {
+      close() {},
+      hasLevel: () => false,
+      loggingEnabled: () => false,
+      perftrc() {},
+      info() {},
+      startGroup() {},
+      endGroup() {},
+      msg() {},
+      getLogFileName: () => undefined,
+    },
+    session: undefined,
+  });
+
+  return projectService;
+}

packages/typescript-estree/src/parseSettings/createParseSettings.ts

@@ -1,5 +1,6 @@
 import debug from 'debug';
 import type * as ts from 'typescript';
+import { createProjectService } from '../create-program/createProjectService';
 
 import { ensureAbsolutePath } from '../create-program/shared';
 import type { TSESTreeOptions } from '../parser-options';
@@ -31,6 +32,10 @@ export function createParseSettings(
       ? options.tsconfigRootDir
       : process.cwd();
   const parseSettings: MutableParseSettings = {
+    // todo: sometimes
+    projectService: createProjectService(),
+    EXPERIMENTAL_useProjectService: true,
+
     allowInvalidAST: options.allowInvalidAST === true,
     code,
     codeFullText,

packages/typescript-estree/src/parseSettings/index.ts

@@ -1,4 +1,5 @@
 import type * as ts from 'typescript';
+import type * as tsserverlibrary from 'typescript/lib/tsserverlibrary';
 
 import type { CanonicalPath } from '../create-program/shared';
 import type { TSESTree } from '../ts-estree';
@@ -10,6 +11,9 @@ type DebugModule = 'typescript-eslint' | 'eslint' | 'typescript';
  * Internal settings used by the parser to run on a file.
  */
 export interface MutableParseSettings {
+  // todo
+  projectService: tsserverlibrary.server.ProjectService | undefined;
+
   /**
    * Prevents the parser from throwing an error if it receives an invalid AST from TypeScript.
    */
@@ -57,6 +61,9 @@ export interface MutableParseSettings {
    */
   errorOnUnknownASTType: boolean;
 
+  // todo
+  EXPERIMENTAL_useProjectService: boolean;
+
   /**
    * Whether TS should use the source files for referenced projects instead of the compiled .d.ts files.
    *

packages/typescript-estree/src/parser.ts

@@ -6,10 +6,12 @@ import { convertError } from './convert';
 import { createDefaultProgram } from './create-program/createDefaultProgram';
 import { createIsolatedProgram } from './create-program/createIsolatedProgram';
 import { createProjectProgram } from './create-program/createProjectProgram';
+import { createProjectService } from './create-program/createProjectService';
 import {
   createNoProgram,
   createSourceFile,
 } from './create-program/createSourceFile';
+import { getWatchProgramsForProjects } from './create-program/getWatchProgramsForProjects';
 import type { ASTAndProgram, CanonicalPath } from './create-program/shared';
 import {
   createProgramFromConfigFile,
@@ -57,8 +59,43 @@ function getProgramAndAST(
     }
   }
 
+  // todo; wrap in function or some such
+  if (parseSettings.projectService) {
+    parseSettings.projectService.openClientFile(
+      parseSettings.filePath,
+      parseSettings.codeFullText,
+    );
+
+    // todo: maybe we'll slap this into the parseSEttings as a property?
+    // const projectService = createProjectServiceProgram(/* parseSettings */);
+    const program = parseSettings.projectService
+      .getScriptInfo(parseSettings.filePath)!
+      .getDefaultProject()
+      .getLanguageService(/*ensureSynchronized*/ true)
+      .getProgram();
+
+    // TODO "Eventually, close the file"
+    // what does this actually do?
+    //
+
+    if (program) {
+      const projectServiceProgram = createProjectProgram(parseSettings, [
+        // LOL TYPES
+        // This'll hoepfully be resolved once they fully move to modules
+        // right now it's two separate files that get dumped out
+        program as ts.Program,
+      ]);
+      if (projectServiceProgram) {
+        return projectServiceProgram;
+      }
+    }
+  }
+
   if (hasFullTypeInformation) {
-    const fromProjectProgram = createProjectProgram(parseSettings);
+    const fromProjectProgram = createProjectProgram(
+      parseSettings,
+      getWatchProgramsForProjects(parseSettings),
+    );
     if (fromProjectProgram) {
       return fromProjectProgram;
     }
@@ -284,3 +321,16 @@ export {
   clearProgramCache,
   clearParseAndGenerateServicesCalls,
 };
+
+// next steps
+// 0. clean up comments
+// 1. ping jake with questions
+//   * what does closing a file do
+// 2. create versions of test suite tailored to this new fancy form
+// 3. testing the bujeezus out of it
+
+// aside:
+// * performance testing - need to work on that
+//    (see TS folks - they do both memory usage and runtime)
+//    memory usage: makes bigger people happy (OOMs)
+//    runtime: more people can use it

packages/typescript-estree/tests/lib/persistentParse.test.ts

@@ -224,7 +224,7 @@ function baseTests(
 }
 
 describe('persistent parse', () => {
-  describe('includes not ending in a slash', () => {
+  describe.only('includes not ending in a slash', () => {
     const tsConfigExcludeBar = {
       include: ['src'],
       exclude: ['./src/bar.ts'],

packages/typescript-estree/tests/lib/semanticInfo.test.ts

@@ -179,7 +179,7 @@ describe('semanticInfo', () => {
     expect(tsComputedPropertyString.kind).toEqual(ts.SyntaxKind.StringLiteral);
   });
 
-  it('imported-file tests', () => {
+  it.only('imported-file tests', () => {
     const fileName = path.resolve(FIXTURES_DIR, 'import-file.src.ts');
     const parseResult = parseCodeAndGenerateServices(
       fs.readFileSync(fileName, 'utf8'),