feat(typescript-estree): always return parserServices

packages/eslint-plugin/src/rules/no-unused-vars-experimental.ts

@@ -68,7 +68,7 @@ export default util.createRule<Options, MessageIds>({
     },
   ],
   create(context, [userOptions]) {
-    const parserServices = util.getParserServices(context);
+    const parserServices = util.getParserServices(context, true);
     const tsProgram = parserServices.program;
     const afterAllDiagnosticsCallbacks: (() => void)[] = [];
 
@@ -189,7 +189,7 @@ export default util.createRule<Options, MessageIds>({
       parent: ts.ParameterDeclaration,
     ): void {
       const name = identifier.getText();
-      // regardless of if the paramter is ignored, track that it had a diagnostic fired on it
+      // regardless of if the parameter is ignored, track that it had a diagnostic fired on it
       unusedParameters.add(identifier);
 
       /*

packages/eslint-plugin/tests/rules/no-unused-vars-experimental.test.ts

@@ -14,8 +14,6 @@ const ruleTester = new RuleTester({
   parserOptions: {
     ecmaVersion: 2018,
     sourceType: 'module',
-    project: './tsconfig.json',
-    tsconfigRootDir: rootDir,
   },
   parser: '@typescript-eslint/parser',
 });

packages/experimental-utils/src/eslint-utils/getParserServices.ts

@@ -11,7 +11,7 @@ export function getParserServices<
   TOptions extends readonly unknown[]
 >(
   context: TSESLint.RuleContext<TMessageIds, TOptions>,
-  allowWithoutFullTypeInformation: boolean = false,
+  allowWithoutFullTypeInformation = false,
 ): ParserServices {
   // backwards compatibility check
   // old versions of the parser would not return any parserServices unless parserOptions.project was set

packages/experimental-utils/src/ts-eslint/Rule.ts

@@ -185,7 +185,7 @@ interface RuleContext<
   /**
    * An object containing parser-provided services for rules
    */
-  parserServices: ParserServices;
+  parserServices?: ParserServices;
 
   /**
    * Returns an array of the ancestors of the currently-traversed node, starting at

packages/typescript-estree/src/parser.ts

@@ -240,10 +240,8 @@ function applyParserOptionsToExtra(options: TSESTreeOptions): void {
    * Allow the user to enable or disable the preservation of the AST node maps
    * during the conversion process.
    */
-  extra.preserveNodeMaps =
-    typeof options.preserveNodeMaps === 'boolean' && options.preserveNodeMaps;
-  if (options.preserveNodeMaps === undefined) {
-    extra.preserveNodeMaps = true;
+  if (typeof options.preserveNodeMaps === 'boolean') {
+    extra.preserveNodeMaps = options.preserveNodeMaps;
   }
 
   extra.createDefaultProgram =
@@ -288,7 +286,6 @@ interface ParseAndGenerateServicesResult<T extends TSESTreeOptions> {
 // Public
 //------------------------------------------------------------------------------
 
-// note - cannot migrate this to an import statement because it will make TSC copy the package.json to the dist folder
 const version: string = require('../package.json').version;
 
 function parse<T extends TSESTreeOptions = TSESTreeOptions>(

packages/typescript-estree/tests/lib/parse.ts

@@ -279,7 +279,9 @@ describe('parse()', () => {
       it(`should parse ${ext} file - ${
         jsxContent ? 'with' : 'without'
       } JSX content - parserOptions.jsx = ${jsxSetting}`, () => {
-        let result: any = {};
+        let result:
+          | parser.ParseAndGenerateServicesResult<typeof config>
+          | undefined;
         const exp = expect(() => {
           result = parser.parseAndGenerateServices(code, {
             ...config,
@@ -294,9 +296,16 @@ describe('parse()', () => {
         }
 
         if (!shouldThrow) {
-          expect(result.services.program).toBeDefined();
-          result.services.program = {}; // reduce noise
-          expect(result).toMatchSnapshot();
+          expect(result?.services.program).toBeDefined();
+          expect(result?.ast).toBeDefined();
+          expect({
+            ...result,
+            services: {
+              ...result?.services,
+              // Reduce noise in snapshot
+              program: {},
+            },
+          }).toMatchSnapshot();
         }
       });
     };

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

@@ -151,15 +151,15 @@ describe('semanticInfo', () => {
     expect(parseResult).toHaveProperty('services.esTreeNodeToTSNodeMap');
     const binaryExpression = (parseResult.ast
       .body[0] as TSESTree.VariableDeclaration).declarations[0].init!;
-    const tsBinaryExpression = parseResult.services.esTreeNodeToTSNodeMap!.get(
+    const tsBinaryExpression = parseResult.services.esTreeNodeToTSNodeMap.get(
       binaryExpression,
     );
     expect(tsBinaryExpression.kind).toEqual(ts.SyntaxKind.BinaryExpression);
 
     const computedPropertyString = ((parseResult.ast
       .body[1] as TSESTree.ClassDeclaration).body
       .body[0] as TSESTree.ClassProperty).key;
-    const tsComputedPropertyString = parseResult.services.esTreeNodeToTSNodeMap!.get(
+    const tsComputedPropertyString = parseResult.services.esTreeNodeToTSNodeMap.get(
       computedPropertyString,
     );
     expect(tsComputedPropertyString.kind).toEqual(ts.SyntaxKind.StringLiteral);
@@ -174,7 +174,7 @@ describe('semanticInfo', () => {
 
     // get type checker
     expect(parseResult).toHaveProperty('services.program.getTypeChecker');
-    const checker = parseResult.services.program!.getTypeChecker();
+    const checker = parseResult.services.program.getTypeChecker();
 
     // get array node (ast shape validated by snapshot)
     // node is defined in other file than the parsed one
@@ -185,14 +185,14 @@ describe('semanticInfo', () => {
     expect(arrayBoundName.name).toBe('arr');
 
     expect(parseResult).toHaveProperty('services.esTreeNodeToTSNodeMap');
-    const tsArrayBoundName = parseResult.services.esTreeNodeToTSNodeMap!.get(
+    const tsArrayBoundName = parseResult.services.esTreeNodeToTSNodeMap.get(
       arrayBoundName,
     );
     expect(tsArrayBoundName).toBeDefined();
     checkNumberArrayType(checker, tsArrayBoundName);
 
     expect(
-      parseResult.services.tsNodeToESTreeNodeMap!.get(tsArrayBoundName),
+      parseResult.services.tsNodeToESTreeNodeMap.get(tsArrayBoundName),
     ).toBe(arrayBoundName);
   });
 
@@ -213,12 +213,12 @@ describe('semanticInfo', () => {
       .declarations[0].id as TSESTree.Identifier;
     expect(boundName.name).toBe('x');
 
-    const tsBoundName = parseResult.services.esTreeNodeToTSNodeMap!.get(
+    const tsBoundName = parseResult.services.esTreeNodeToTSNodeMap.get(
       boundName,
     );
     expect(tsBoundName).toBeDefined();
 
-    expect(parseResult.services.tsNodeToESTreeNodeMap!.get(tsBoundName)).toBe(
+    expect(parseResult.services.tsNodeToESTreeNodeMap.get(tsBoundName)).toBe(
       boundName,
     );
   });
@@ -286,7 +286,7 @@ function testIsolatedFile(
 ): void {
   // get type checker
   expect(parseResult).toHaveProperty('services.program.getTypeChecker');
-  const checker = parseResult.services.program!.getTypeChecker();
+  const checker = parseResult.services.program.getTypeChecker();
 
   // get number node (ast shape validated by snapshot)
   const declaration = (parseResult.ast.body[0] as TSESTree.VariableDeclaration)
@@ -296,7 +296,7 @@ function testIsolatedFile(
   expect(parseResult).toHaveProperty('services.esTreeNodeToTSNodeMap');
 
   // get corresponding TS node
-  const tsArrayMember = parseResult.services.esTreeNodeToTSNodeMap!.get(
+  const tsArrayMember = parseResult.services.esTreeNodeToTSNodeMap.get(
     arrayMember,
   );
   expect(tsArrayMember).toBeDefined();
@@ -312,19 +312,17 @@ function testIsolatedFile(
 
   // make sure it maps back to original ESTree node
   expect(parseResult).toHaveProperty('services.tsNodeToESTreeNodeMap');
-  expect(parseResult.services.tsNodeToESTreeNodeMap!.get(tsArrayMember)).toBe(
+  expect(parseResult.services.tsNodeToESTreeNodeMap.get(tsArrayMember)).toBe(
     arrayMember,
   );
 
   // get bound name
   const boundName = declaration.id as TSESTree.Identifier;
   expect(boundName.name).toBe('x');
-  const tsBoundName = parseResult.services.esTreeNodeToTSNodeMap!.get(
-    boundName,
-  );
+  const tsBoundName = parseResult.services.esTreeNodeToTSNodeMap.get(boundName);
   expect(tsBoundName).toBeDefined();
   checkNumberArrayType(checker, tsBoundName);
-  expect(parseResult.services.tsNodeToESTreeNodeMap!.get(tsBoundName)).toBe(
+  expect(parseResult.services.tsNodeToESTreeNodeMap.get(tsBoundName)).toBe(
     boundName,
   );
 }