typescript-eslint · bradzacher · Jan 9, 2020 · Dec 26, 2019 · Dec 26, 2019 · Jan 6, 2020
diff --git a/packages/eslint-plugin/src/rules/await-thenable.ts b/packages/eslint-plugin/src/rules/await-thenable.ts
@@ -26,9 +26,7 @@ export default util.createRule({
 
     return {
       AwaitExpression(node): void {
-        const originalNode = parserServices.esTreeNodeToTSNodeMap.get<
-          ts.AwaitExpression
-        >(node);
+        const originalNode = parserServices.esTreeNodeToTSNodeMap.get(node);
         const type = checker.getTypeAtLocation(originalNode.expression);
 
         if (

diff --git a/packages/eslint-plugin/src/rules/no-floating-promises.ts b/packages/eslint-plugin/src/rules/no-floating-promises.ts
@@ -44,9 +44,7 @@ export default util.createRule<Options, 'floating'>({
 
     return {
       ExpressionStatement(node): void {
-        const { expression } = parserServices.esTreeNodeToTSNodeMap.get<
-          ts.ExpressionStatement
-        >(node);
+        const { expression } = parserServices.esTreeNodeToTSNodeMap.get(node);
 
         if (isUnhandledPromise(checker, expression)) {
           context.report({

diff --git a/packages/eslint-plugin/src/rules/no-for-in-array.ts b/packages/eslint-plugin/src/rules/no-for-in-array.ts
@@ -23,9 +23,7 @@ export default util.createRule({
       ForInStatement(node): void {
         const parserServices = util.getParserServices(context);
         const checker = parserServices.program.getTypeChecker();
-        const originalNode = parserServices.esTreeNodeToTSNodeMap.get<
-          ts.ForInStatement
-        >(node);
+        const originalNode = parserServices.esTreeNodeToTSNodeMap.get(node);
 
         const type = checker.getTypeAtLocation(originalNode.expression);
 

diff --git a/packages/eslint-plugin/src/rules/no-misused-promises.ts b/packages/eslint-plugin/src/rules/no-misused-promises.ts
@@ -99,9 +99,7 @@ export default util.createRule<Options, 'conditional' | 'voidReturn'>({
         | TSESTree.OptionalCallExpression
         | TSESTree.NewExpression,
     ): void {
-      const tsNode = parserServices.esTreeNodeToTSNodeMap.get<
-        ts.CallExpression | ts.NewExpression
-      >(node);
+      const tsNode = parserServices.esTreeNodeToTSNodeMap.get(node);
       const voidParams = voidFunctionParams(checker, tsNode);
       if (voidParams.size === 0) {
         return;

diff --git a/packages/eslint-plugin/src/rules/no-unnecessary-condition.ts b/packages/eslint-plugin/src/rules/no-unnecessary-condition.ts
@@ -121,7 +121,7 @@ export default createRule<Options, MessageId>({
     const checker = service.program.getTypeChecker();
     const sourceCode = context.getSourceCode();
 
-    function getNodeType(node: TSESTree.Node): ts.Type {
+    function getNodeType(node: TSESTree.Expression): ts.Type {
       const tsNode = service.esTreeNodeToTSNodeMap.get(node);
       return getConstrainedTypeAtLocation(checker, tsNode);
     }
@@ -130,7 +130,7 @@ export default createRule<Options, MessageId>({
      * Checks if a conditional node is necessary:
      * if the type of the node is always true or always false, it's not necessary.
      */
-    function checkNode(node: TSESTree.Node): void {
+    function checkNode(node: TSESTree.Expression): void {
       const type = getNodeType(node);
 
       // Conditional is always necessary if it involves:
@@ -160,7 +160,7 @@ export default createRule<Options, MessageId>({
       }
     }
 
-    function checkNodeForNullish(node: TSESTree.Node): void {
+    function checkNodeForNullish(node: TSESTree.Expression): void {
       const type = getNodeType(node);
       // Conditional is always necessary if it involves `any` or `unknown`
       if (isTypeFlagSet(type, ts.TypeFlags.Any | ts.TypeFlags.Unknown)) {

diff --git a/packages/eslint-plugin/src/rules/no-unnecessary-qualifier.ts b/packages/eslint-plugin/src/rules/no-unnecessary-qualifier.ts
@@ -74,7 +74,7 @@ export default util.createRule({
     }
 
     function qualifierIsUnnecessary(
-      qualifier: TSESTree.Node,
+      qualifier: TSESTree.EntityName | TSESTree.MemberExpression,
       name: TSESTree.Identifier,
     ): boolean {
       const tsQualifier = esTreeNodeToTSNodeMap.get(qualifier);
@@ -110,7 +110,7 @@ export default util.createRule({
 
     function visitNamespaceAccess(
       node: TSESTree.Node,
-      qualifier: TSESTree.Node,
+      qualifier: TSESTree.EntityName | TSESTree.MemberExpression,
       name: TSESTree.Identifier,
     ): void {
       // Only look for nested qualifier errors if we didn't already fail on the outer qualifier.
@@ -132,7 +132,12 @@ export default util.createRule({
       }
     }
 
-    function enterDeclaration(node: TSESTree.Node): void {
+    function enterDeclaration(
+      node:
+        | TSESTree.TSModuleDeclaration
+        | TSESTree.TSEnumDeclaration
+        | TSESTree.ExportNamedDeclaration,
+    ): void {
       namespacesInScope.push(esTreeNodeToTSNodeMap.get(node));
     }
 
@@ -152,7 +157,9 @@ export default util.createRule({
       return node.type === AST_NODE_TYPES.MemberExpression && !node.computed;
     }
 
-    function isEntityNameExpression(node: TSESTree.Node): boolean {
+    function isEntityNameExpression(
+      node: TSESTree.Node,
+    ): node is TSESTree.Identifier | TSESTree.MemberExpression {
       return (
         node.type === AST_NODE_TYPES.Identifier ||
         (isPropertyAccessExpression(node) &&

diff --git a/packages/eslint-plugin/src/rules/no-unnecessary-type-arguments.ts b/packages/eslint-plugin/src/rules/no-unnecessary-type-arguments.ts
@@ -5,10 +5,14 @@ import * as util from '../util';
 import { findFirstResult } from '../util';
 
 type ParameterCapableTSNode =
+  | ts.TaggedTemplateExpression
+  | ts.ImportTypeNode
   | ts.CallExpression
   | ts.NewExpression
   | ts.TypeReferenceNode
-  | ts.ExpressionWithTypeArguments;
+  | ts.ExpressionWithTypeArguments
+  | ts.JsxOpeningElement
+  | ts.JsxSelfClosingElement;
 
 type MessageIds = 'unnecessaryTypeParameter';
 
@@ -67,9 +71,7 @@ export default util.createRule<[], MessageIds>({
 
     return {
       TSTypeParameterInstantiation(node): void {
-        const expression = parserServices.esTreeNodeToTSNodeMap.get<
-          ParameterCapableTSNode
-        >(node);
+        const expression = parserServices.esTreeNodeToTSNodeMap.get(node);
 
         const typeParameters = getTypeParametersFromNode(expression, checker);
         if (typeParameters) {

diff --git a/packages/eslint-plugin/src/rules/no-unnecessary-type-assertion.ts b/packages/eslint-plugin/src/rules/no-unnecessary-type-assertion.ts
@@ -168,9 +168,7 @@ export default util.createRule<Options, MessageIds>({
 
     return {
       TSNonNullExpression(node): void {
-        const originalNode = parserServices.esTreeNodeToTSNodeMap.get<
-          ts.NonNullExpression
-        >(node);
+        const originalNode = parserServices.esTreeNodeToTSNodeMap.get(node);
         const type = util.getConstrainedTypeAtLocation(
           checker,
           originalNode.expression,
@@ -252,9 +250,7 @@ export default util.createRule<Options, MessageIds>({
           return;
         }
 
-        const originalNode = parserServices.esTreeNodeToTSNodeMap.get<
-          ts.AssertionExpression
-        >(node);
+        const originalNode = parserServices.esTreeNodeToTSNodeMap.get(node);
         const castType = checker.getTypeAtLocation(originalNode);
 
         if (

diff --git a/packages/eslint-plugin/src/rules/no-unused-vars-experimental.ts b/packages/eslint-plugin/src/rules/no-unused-vars-experimental.ts
@@ -290,7 +290,7 @@ export default util.createRule<Options, MessageIds>({
     }
 
     return {
-      'Program:exit'(program: TSESTree.Node): void {
+      'Program:exit'(program: TSESTree.Program): void {
         const tsNode = parserServices.esTreeNodeToTSNodeMap.get(program);
         const sourceFile = util.getSourceFileOfNode(tsNode);
         const diagnostics = tsProgram.getSemanticDiagnostics(sourceFile);

diff --git a/packages/eslint-plugin/src/rules/prefer-nullish-coalescing.ts b/packages/eslint-plugin/src/rules/prefer-nullish-coalescing.ts
@@ -4,7 +4,6 @@ import {
   TSESLint,
   TSESTree,
 } from '@typescript-eslint/experimental-utils';
-import * as ts from 'typescript';
 import * as util from '../util';
 
 export type Options = [
@@ -75,9 +74,7 @@ export default util.createRule<Options, MessageIds>({
       'LogicalExpression[operator = "||"]'(
         node: TSESTree.LogicalExpression,
       ): void {
-        const tsNode = parserServices.esTreeNodeToTSNodeMap.get<
-          ts.BinaryExpression
-        >(node);
+        const tsNode = parserServices.esTreeNodeToTSNodeMap.get(node);
         const type = checker.getTypeAtLocation(tsNode.left);
         const isNullish = util.isNullableType(type, { allowUndefined: true });
         if (!isNullish) {

diff --git a/packages/eslint-plugin/src/rules/prefer-readonly.ts b/packages/eslint-plugin/src/rules/prefer-readonly.ts
@@ -5,6 +5,7 @@ import { typeIsOrHasBaseType } from '../util';
 import {
   TSESTree,
   AST_NODE_TYPES,
+  TSESTreeToTSNode,
 } from '@typescript-eslint/experimental-utils';
 
 type MessageIds = 'preferReadonly';
@@ -15,6 +16,8 @@ type Options = [
   },
 ];
 
+type ConstructorTSType = TSESTreeToTSNode<TSESTree.MethodDefinition>;
+
 const functionScopeBoundaries = [
   AST_NODE_TYPES.ArrowFunctionExpression,
   AST_NODE_TYPES.FunctionDeclaration,
@@ -135,15 +138,21 @@ export default util.createRule<Options, MessageIds>({
       return false;
     }
 
-    function isConstructor(node: TSESTree.Node): boolean {
+    function isConstructor(
+      node: TSESTree.Node,
+    ): node is TSESTree.MethodDefinition {
       return (
         node.type === AST_NODE_TYPES.MethodDefinition &&
         node.kind === 'constructor'
       );
     }
 
     function isFunctionScopeBoundaryInStack(
-      node: TSESTree.Node,
+      node:
+        | TSESTree.ArrowFunctionExpression
+        | TSESTree.FunctionDeclaration
+        | TSESTree.FunctionExpression
+        | TSESTree.MethodDefinition,
     ): boolean | tsutils.ScopeBoundary {
       if (classScopeStack.length === 0) {
         return false;
@@ -208,10 +217,10 @@ export default util.createRule<Options, MessageIds>({
         }
       },
       MemberExpression(node): void {
-        const tsNode = parserServices.esTreeNodeToTSNodeMap.get<
-          ts.PropertyAccessExpression
-        >(node);
         if (classScopeStack.length !== 0 && !node.computed) {
+          const tsNode = parserServices.esTreeNodeToTSNodeMap.get(
+            node,
+          ) as ts.PropertyAccessExpression;
           handlePropertyAccessExpression(
             tsNode,
             tsNode.parent,
@@ -228,9 +237,7 @@ export default util.createRule<Options, MessageIds>({
       ): void {
         if (isConstructor(node)) {
           classScopeStack[classScopeStack.length - 1].enterConstructor(
-            parserServices.esTreeNodeToTSNodeMap.get<ts.ConstructorDeclaration>(
-              node,
-            ),
+            parserServices.esTreeNodeToTSNodeMap.get(node),
           );
         } else if (isFunctionScopeBoundaryInStack(node)) {
           classScopeStack[classScopeStack.length - 1].enterNonConstructor();
@@ -339,7 +346,7 @@ class ClassScope {
     ).add(node.name.text);
   }
 
-  public enterConstructor(node: ts.ConstructorDeclaration): void {
+  public enterConstructor(node: ConstructorTSType): void {
     this.constructorScopeDepth = DIRECTLY_INSIDE_CONSTRUCTOR;
 
     for (const parameter of node.parameters) {

diff --git a/packages/eslint-plugin/src/rules/prefer-regexp-exec.ts b/packages/eslint-plugin/src/rules/prefer-regexp-exec.ts
@@ -30,7 +30,7 @@ export default createRule({
      * Check if a given node is a string.
      * @param node The node to check.
      */
-    function isStringType(node: TSESTree.Node): boolean {
+    function isStringType(node: TSESTree.LeftHandSideExpression): boolean {
       const objectType = typeChecker.getTypeAtLocation(
         service.esTreeNodeToTSNodeMap.get(node),
       );

diff --git a/packages/eslint-plugin/src/rules/prefer-string-starts-ends-with.ts b/packages/eslint-plugin/src/rules/prefer-string-starts-ends-with.ts
@@ -45,7 +45,7 @@ export default createRule({
      * Check if a given node is a string.
      * @param node The node to check.
      */
-    function isStringType(node: TSESTree.Node): boolean {
+    function isStringType(node: TSESTree.LeftHandSideExpression): boolean {
       const objectType = typeChecker.getTypeAtLocation(
         service.esTreeNodeToTSNodeMap.get(node),
       );

diff --git a/packages/eslint-plugin/src/rules/promise-function-async.ts b/packages/eslint-plugin/src/rules/promise-function-async.ts
@@ -90,7 +90,14 @@ export default util.createRule<Options, MessageIds>({
     const parserServices = util.getParserServices(context);
     const checker = parserServices.program.getTypeChecker();
 
-    function validateNode(node: TSESTree.Node): void {
+    function validateNode(
+      node:
+        | TSESTree.ArrowFunctionExpression
+        | TSESTree.FunctionDeclaration
+        | TSESTree.FunctionExpression
+        | TSESTree.MethodDefinition
+        | TSESTree.TSAbstractMethodDefinition,
+    ): void {
       const originalNode = parserServices.esTreeNodeToTSNodeMap.get(node);
       const signatures = checker
         .getTypeAtLocation(originalNode)

diff --git a/packages/eslint-plugin/src/rules/require-await.ts b/packages/eslint-plugin/src/rules/require-await.ts
@@ -66,9 +66,7 @@ export default util.createRule<Options, MessageIds>({
       ForOfStatement: rules.ForOfStatement,
 
       ReturnStatement(node): void {
-        const { expression } = parserServices.esTreeNodeToTSNodeMap.get<
-          ts.ReturnStatement
-        >(node);
+        const { expression } = parserServices.esTreeNodeToTSNodeMap.get(node);
         if (expression && isThenableType(expression)) {
           // tell the base rule to mark the scope as having an await so it ignores it
           rules.AwaitExpression();

diff --git a/packages/eslint-plugin/src/rules/restrict-plus-operands.ts b/packages/eslint-plugin/src/rules/restrict-plus-operands.ts
@@ -96,7 +96,7 @@ export default util.createRule<Options, MessageIds>({
      * Helper function to get base type of node
      * @param node the node to be evaluated.
      */
-    function getNodeType(node: TSESTree.Node): BaseLiteral {
+    function getNodeType(node: TSESTree.Expression): BaseLiteral {
       const tsNode = service.esTreeNodeToTSNodeMap.get(node);
       const type = typeChecker.getTypeAtLocation(tsNode);
 

diff --git a/packages/eslint-plugin/src/rules/restrict-template-expressions.ts b/packages/eslint-plugin/src/rules/restrict-template-expressions.ts
@@ -92,7 +92,7 @@ export default util.createRule<Options, MessageId>({
      * Helper function to get base type of node
      * @param node the node to be evaluated.
      */
-    function getNodeType(node: TSESTree.Node): BaseType[] {
+    function getNodeType(node: TSESTree.Expression): BaseType[] {
       const tsNode = service.esTreeNodeToTSNodeMap.get(node);
       const type = typeChecker.getTypeAtLocation(tsNode);
 

diff --git a/packages/eslint-plugin/src/rules/return-await.ts b/packages/eslint-plugin/src/rules/return-await.ts
@@ -135,9 +135,7 @@ export default util.createRule({
         }
       },
       ReturnStatement(node): void {
-        const originalNode = parserServices.esTreeNodeToTSNodeMap.get<
-          ts.ReturnStatement
-        >(node);
+        const originalNode = parserServices.esTreeNodeToTSNodeMap.get(node);
 
         const { expression } = originalNode;
 

diff --git a/packages/eslint-plugin/src/rules/strict-boolean-expressions.ts b/packages/eslint-plugin/src/rules/strict-boolean-expressions.ts
@@ -66,10 +66,8 @@ export default util.createRule<Options, 'strictBooleanExpression'>({
     /**
      * Determines if the node is safe for boolean type
      */
-    function isValidBooleanNode(node: TSESTree.Node): boolean {
-      const tsNode = service.esTreeNodeToTSNodeMap.get<ts.ExpressionStatement>(
-        node,
-      );
+    function isValidBooleanNode(node: TSESTree.Expression): boolean {
+      const tsNode = service.esTreeNodeToTSNodeMap.get(node);
       const type = util.getConstrainedTypeAtLocation(checker, tsNode);
 
       if (tsutils.isTypeFlagSet(type, ts.TypeFlags.BooleanLike)) {

diff --git a/packages/experimental-utils/src/index.ts b/packages/experimental-utils/src/index.ts
@@ -15,5 +15,6 @@ export {
   AST_NODE_TYPES,
   AST_TOKEN_TYPES,
   TSESTree,
+  TSESTreeToTSNode,
 } from '@typescript-eslint/typescript-estree/dist/ts-estree';
 export { ParserServices } from '@typescript-eslint/typescript-estree/dist/parser-options';