feat: remove partial type-information program (#6066)

Author: bradzacher

packages/eslint-plugin/src/rules/consistent-type-exports.ts

@@ -1,8 +1,4 @@
-import type {
-  ParserServices,
-  TSESLint,
-  TSESTree,
-} from '@typescript-eslint/utils';
+import type { TSESLint, TSESTree } from '@typescript-eslint/utils';
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 import { SymbolFlags } from 'typescript';
 
@@ -75,6 +71,28 @@ export default util.createRule<Options, MessageIds>({
     const sourceExportsMap: { [key: string]: SourceExports } = {};
     const parserServices = util.getParserServices(context);
 
+    /**
+     * Helper for identifying if an export specifier resolves to a
+     * JavaScript value or a TypeScript type.
+     *
+     * @returns True/false if is a type or not, or undefined if the specifier
+     * can't be resolved.
+     */
+    function isSpecifierTypeBased(
+      specifier: TSESTree.ExportSpecifier,
+    ): boolean | undefined {
+      const checker = parserServices.program.getTypeChecker();
+      const node = parserServices.esTreeNodeToTSNodeMap.get(specifier.exported);
+      const symbol = checker.getSymbolAtLocation(node);
+      const aliasedSymbol = checker.getAliasedSymbol(symbol!);
+
+      if (!aliasedSymbol || aliasedSymbol.escapedName === 'unknown') {
+        return undefined;
+      }
+
+      return !(aliasedSymbol.flags & SymbolFlags.Value);
+    }
+
     return {
       ExportNamedDeclaration(node: TSESTree.ExportNamedDeclaration): void {
         // Coerce the source into a string for use as a lookup entry.
@@ -112,7 +130,7 @@ export default util.createRule<Options, MessageIds>({
               continue;
             }
 
-            const isTypeBased = isSpecifierTypeBased(parserServices, specifier);
+            const isTypeBased = isSpecifierTypeBased(specifier);
 
             if (isTypeBased === true) {
               typeBasedSpecifiers.push(specifier);
@@ -199,29 +217,6 @@ export default util.createRule<Options, MessageIds>({
   },
 });
 
-/**
- * Helper for identifying if an export specifier resolves to a
- * JavaScript value or a TypeScript type.
- *
- * @returns True/false if is a type or not, or undefined if the specifier
- * can't be resolved.
- */
-function isSpecifierTypeBased(
-  parserServices: ParserServices,
-  specifier: TSESTree.ExportSpecifier,
-): boolean | undefined {
-  const checker = parserServices.program.getTypeChecker();
-  const node = parserServices.esTreeNodeToTSNodeMap.get(specifier.exported);
-  const symbol = checker.getSymbolAtLocation(node);
-  const aliasedSymbol = checker.getAliasedSymbol(symbol!);
-
-  if (!aliasedSymbol || aliasedSymbol.escapedName === 'unknown') {
-    return undefined;
-  }
-
-  return !(aliasedSymbol.flags & SymbolFlags.Value);
-}
-
 /**
  * Inserts "type" into an export.
  *

packages/eslint-plugin/src/rules/naming-convention.ts

@@ -90,10 +90,8 @@ export default util.createRule<Options, MessageIds>({
 
     const validators = parseOptions(context);
 
-    // getParserServices(context, false) -- dirty hack to work around the docs checker test...
-    const compilerOptions = util
-      .getParserServices(context, true)
-      .program.getCompilerOptions();
+    const compilerOptions =
+      util.getParserServices(context, true).program?.getCompilerOptions() ?? {};
     function handleMember(
       validator: ValidatorFunction | null,
       node:

packages/eslint-plugin/tests/docs.test.ts

@@ -120,6 +120,10 @@ describe('Validating rule docs', () => {
 });
 
 describe('Validating rule metadata', () => {
+  const rulesThatRequireTypeInformationInAWayThatsHardToDetect = new Set([
+    // the core rule file doesn't use type information, instead it's used in `src/rules/naming-convention-utils/validator.ts`
+    'naming-convention',
+  ]);
   function requiresFullTypeInformation(content: string): boolean {
     return /getParserServices(\(\s*[^,\s)]+)\s*(,\s*false\s*)?\)/.test(content);
   }
@@ -135,6 +139,13 @@ describe('Validating rule metadata', () => {
       });
 
       it('`requiresTypeChecking` should be set if the rule uses type information', () => {
+        if (
+          rulesThatRequireTypeInformationInAWayThatsHardToDetect.has(ruleName)
+        ) {
+          expect(true).toEqual(rule.meta.docs?.requiresTypeChecking ?? false);
+          return;
+        }
+
         // quick-and-dirty check to see if it uses parserServices
         // not perfect but should be good enough
         const ruleFileContents = fs.readFileSync(

packages/parser/src/index.ts

@@ -1,6 +1,8 @@
 export { parse, parseForESLint, ParserOptions } from './parser';
 export {
   ParserServices,
+  ParserServicesWithTypeInformation,
+  ParserServicesWithoutTypeInformation,
   clearCaches,
   createProgram,
 } from '@typescript-eslint/typescript-estree';

packages/parser/src/parser.ts

@@ -128,7 +128,7 @@ function parseForESLint(
   ast.sourceType = options.sourceType;
 
   let emitDecoratorMetadata = options.emitDecoratorMetadata === true;
-  if (services.hasFullTypeInformation) {
+  if (services.program) {
     // automatically apply the options configured for the program
     const compilerOptions = services.program.getCompilerOptions();
     if (analyzeOptions.lib == null) {

packages/type-utils/tests/isTypeReadonly.test.ts

@@ -7,6 +7,7 @@ import {
   type ReadonlynessOptions,
   isTypeReadonly,
 } from '../src/isTypeReadonly';
+import { expectToHaveParserServices } from './test-utils/expectToHaveParserServices';
 
 describe('isTypeReadonly', () => {
   const rootDir = path.join(__dirname, 'fixtures');
@@ -21,6 +22,7 @@ describe('isTypeReadonly', () => {
         filePath: path.join(rootDir, 'file.ts'),
         tsconfigRootDir: rootDir,
       });
+      expectToHaveParserServices(services);
       const checker = services.program.getTypeChecker();
       const esTreeNodeToTSNodeMap = services.esTreeNodeToTSNodeMap;
 

packages/type-utils/tests/isUnsafeAssignment.test.ts

@@ -4,6 +4,7 @@ import path from 'path';
 import type * as ts from 'typescript';
 
 import { isUnsafeAssignment } from '../src/isUnsafeAssignment';
+import { expectToHaveParserServices } from './test-utils/expectToHaveParserServices';
 
 describe('isUnsafeAssignment', () => {
   const rootDir = path.join(__dirname, 'fixtures');
@@ -19,6 +20,7 @@ describe('isUnsafeAssignment', () => {
       filePath: path.join(rootDir, 'file.ts'),
       tsconfigRootDir: rootDir,
     });
+    expectToHaveParserServices(services);
     const checker = services.program.getTypeChecker();
     const esTreeNodeToTSNodeMap = services.esTreeNodeToTSNodeMap;
 

packages/type-utils/tests/test-utils/expectToHaveParserServices.ts

@@ -0,0 +1,12 @@
+import type {
+  ParserServices,
+  ParserServicesWithTypeInformation,
+} from '@typescript-eslint/typescript-estree';
+
+export function expectToHaveParserServices(
+  services: ParserServices | null | undefined,
+): asserts services is ParserServicesWithTypeInformation {
+  expect(services?.program).toBeDefined();
+  expect(services?.esTreeNodeToTSNodeMap).toBeDefined();
+  expect(services?.tsNodeToESTreeNodeMap).toBeDefined();
+}

packages/typescript-estree/jest.config.js

@@ -5,7 +5,7 @@
 module.exports = {
   ...require('../../jest.config.base.js'),
   testRegex: [
-    './tests/lib/.*\\.ts$',
+    './tests/lib/.*\\.test\\.ts$',
     './tests/ast-alignment/spec\\.ts$',
     './tests/[^/]+\\.test\\.ts$',
   ],

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

@@ -3,7 +3,7 @@ import path from 'path';
 import * as ts from 'typescript';
 
 import type { ParseSettings } from '../parseSettings';
-import type { ASTAndProgram } from './shared';
+import type { ASTAndDefiniteProgram } from './shared';
 import {
   createDefaultCompilerOptionsFromExtra,
   getModuleResolver,
@@ -20,7 +20,7 @@ const log = debug('typescript-eslint:typescript-estree:createDefaultProgram');
  */
 function createDefaultProgram(
   parseSettings: ParseSettings,
-): ASTAndProgram | undefined {
+): ASTAndDefiniteProgram | undefined {
   log(
     'Getting default program for: %s',
     parseSettings.filePath || 'unnamed file',