feat(experimental-utils): moved types eslint-plugin util to experimental-utils

packages/eslint-plugin/src/rules/await-thenable.ts

@@ -1,3 +1,4 @@
+import { ESLintUtils } from '@typescript-eslint/experimental-utils';
 import * as tsutils from 'tsutils';
 
 import * as util from '../util';
@@ -29,8 +30,8 @@ export default util.createRule({
         const type = checker.getTypeAtLocation(originalNode.expression);
 
         if (
-          !util.isTypeAnyType(type) &&
-          !util.isTypeUnknownType(type) &&
+          !ESLintUtils.isTypeAnyType(type) &&
+          !ESLintUtils.isTypeUnknownType(type) &&
           !tsutils.isThenableType(checker, originalNode.expression, type)
         ) {
           context.report({

packages/eslint-plugin/src/rules/no-base-to-string.ts

@@ -1,6 +1,7 @@
 import {
   TSESTree,
   AST_NODE_TYPES,
+  ESLintUtils,
 } from '@typescript-eslint/experimental-utils';
 import * as ts from 'typescript';
 
@@ -99,7 +100,9 @@ export default util.createRule<Options, MessageIds>({
         return Usefulness.Always;
       }
 
-      if (ignoredTypeNames.includes(util.getTypeName(typeChecker, type))) {
+      if (
+        ignoredTypeNames.includes(ESLintUtils.getTypeName(typeChecker, type))
+      ) {
         return Usefulness.Always;
       }
 
@@ -165,9 +168,11 @@ export default util.createRule<Options, MessageIds>({
           parserServices.esTreeNodeToTSNodeMap.get(node.right),
         );
 
-        if (util.getTypeName(typeChecker, leftType) === 'string') {
+        if (ESLintUtils.getTypeName(typeChecker, leftType) === 'string') {
           checkExpression(node.right, rightType);
-        } else if (util.getTypeName(typeChecker, rightType) === 'string') {
+        } else if (
+          ESLintUtils.getTypeName(typeChecker, rightType) === 'string'
+        ) {
           checkExpression(node.left, leftType);
         }
       },

packages/eslint-plugin/src/rules/no-confusing-void-expression.ts

@@ -2,6 +2,7 @@ import {
   AST_NODE_TYPES,
   TSESLint,
   TSESTree,
+  ESLintUtils,
 } from '@typescript-eslint/experimental-utils';
 import * as tsutils from 'tsutils';
 import * as ts from 'typescript';
@@ -85,7 +86,7 @@ export default util.createRule<Options, MessageId>({
         const parserServices = util.getParserServices(context);
         const checker = parserServices.program.getTypeChecker();
         const tsNode = parserServices.esTreeNodeToTSNodeMap.get(node);
-        const type = util.getConstrainedTypeAtLocation(checker, tsNode);
+        const type = ESLintUtils.getConstrainedTypeAtLocation(checker, tsNode);
         if (!tsutils.isTypeFlagSet(type, ts.TypeFlags.VoidLike)) {
           // not a void expression
           return;

packages/eslint-plugin/src/rules/no-for-in-array.ts

@@ -1,3 +1,4 @@
+import { ESLintUtils } from '@typescript-eslint/experimental-utils';
 import * as ts from 'typescript';
 import * as util from '../util';
 
@@ -25,13 +26,13 @@ export default util.createRule({
         const checker = parserServices.program.getTypeChecker();
         const originalNode = parserServices.esTreeNodeToTSNodeMap.get(node);
 
-        const type = util.getConstrainedTypeAtLocation(
+        const type = ESLintUtils.getConstrainedTypeAtLocation(
           checker,
           originalNode.expression,
         );
 
         if (
-          util.isTypeArrayTypeOrUnionOfArrayTypes(type, checker) ||
+          ESLintUtils.isTypeArrayTypeOrUnionOfArrayTypes(type, checker) ||
           (type.flags & ts.TypeFlags.StringLike) !== 0
         ) {
           context.report({

packages/eslint-plugin/src/rules/no-throw-literal.ts

@@ -3,6 +3,7 @@ import * as util from '../util';
 import {
   TSESTree,
   AST_NODE_TYPES,
+  ESLintUtils,
 } from '@typescript-eslint/experimental-utils';
 
 export default util.createRule({
@@ -79,8 +80,8 @@ export default util.createRule({
       }
 
       if (
-        util.isTypeAnyType(type) ||
-        util.isTypeUnknownType(type) ||
+        ESLintUtils.isTypeAnyType(type) ||
+        ESLintUtils.isTypeUnknownType(type) ||
         isErrorLike(type)
       ) {
         return;

packages/eslint-plugin/src/rules/no-unnecessary-boolean-literal-compare.ts

@@ -1,6 +1,7 @@
 import {
   AST_NODE_TYPES,
   TSESTree,
+  ESLintUtils,
 } from '@typescript-eslint/experimental-utils';
 import * as tsutils from 'tsutils';
 import * as ts from 'typescript';
@@ -159,7 +160,7 @@ export default util.createRule<Options, MessageIds>({
     function deconstructComparison(
       node: TSESTree.BinaryExpression,
     ): BooleanComparison | undefined {
-      const comparisonType = util.getEqualsKind(node.operator);
+      const comparisonType = ESLintUtils.getEqualsKind(node.operator);
       if (!comparisonType) {
         return undefined;
       }

packages/eslint-plugin/src/rules/no-unnecessary-condition.ts

@@ -2,6 +2,7 @@ import {
   TSESTree,
   AST_NODE_TYPES,
   AST_TOKEN_TYPES,
+  ESLintUtils,
 } from '@typescript-eslint/experimental-utils';
 import * as ts from 'typescript';
 import {
@@ -13,17 +14,11 @@ import {
   isStrictCompilerOptionEnabled,
 } from 'tsutils';
 import {
-  isTypeFlagSet,
   createRule,
   getParserServices,
-  getConstrainedTypeAtLocation,
-  isNullableType,
   nullThrows,
   NullThrowsReasons,
   isIdentifier,
-  isTypeAnyType,
-  isTypeUnknownType,
-  getTypeName,
   getTypeOfPropertyOfName,
 } from '../util';
 
@@ -37,15 +32,15 @@ const isPossiblyFalsy = (type: ts.Type): boolean =>
     // PossiblyFalsy flag includes literal values, so exclude ones that
     // are definitely truthy
     .filter(t => !isTruthyLiteral(t))
-    .some(type => isTypeFlagSet(type, ts.TypeFlags.PossiblyFalsy));
+    .some(type => ESLintUtils.isTypeFlagSet(type, ts.TypeFlags.PossiblyFalsy));
 
 const isPossiblyTruthy = (type: ts.Type): boolean =>
   unionTypeParts(type).some(type => !isFalsyType(type));
 
 // Nullish utilities
 const nullishFlag = ts.TypeFlags.Undefined | ts.TypeFlags.Null;
 const isNullishType = (type: ts.Type): boolean =>
-  isTypeFlagSet(type, nullishFlag);
+  ESLintUtils.isTypeFlagSet(type, nullishFlag);
 
 const isPossiblyNullish = (type: ts.Type): boolean =>
   unionTypeParts(type).some(isNullishType);
@@ -169,7 +164,7 @@ export default createRule<Options, MessageId>({
 
     function getNodeType(node: TSESTree.Node): ts.Type {
       const tsNode = service.esTreeNodeToTSNodeMap.get(node);
-      return getConstrainedTypeAtLocation(checker, tsNode);
+      return ESLintUtils.getConstrainedTypeAtLocation(checker, tsNode);
     }
 
     function nodeIsArrayType(node: TSESTree.Expression): boolean {
@@ -238,16 +233,16 @@ export default createRule<Options, MessageId>({
       if (
         unionTypeParts(type).some(
           part =>
-            isTypeAnyType(part) ||
-            isTypeUnknownType(part) ||
-            isTypeFlagSet(part, ts.TypeFlags.TypeParameter),
+            ESLintUtils.isTypeAnyType(part) ||
+            ESLintUtils.isTypeUnknownType(part) ||
+            ESLintUtils.isTypeFlagSet(part, ts.TypeFlags.TypeParameter),
         )
       ) {
         return;
       }
       let messageId: MessageId | null = null;
 
-      if (isTypeFlagSet(type, ts.TypeFlags.Never)) {
+      if (ESLintUtils.isTypeFlagSet(type, ts.TypeFlags.Never)) {
         messageId = 'never';
       } else if (!isPossiblyTruthy(type)) {
         messageId = !isUnaryNotArgument ? 'alwaysFalsy' : 'alwaysTruthy';
@@ -269,12 +264,15 @@ export default createRule<Options, MessageId>({
       }
       const type = getNodeType(node);
       // Conditional is always necessary if it involves `any` or `unknown`
-      if (isTypeAnyType(type) || isTypeUnknownType(type)) {
+      if (
+        ESLintUtils.isTypeAnyType(type) ||
+        ESLintUtils.isTypeUnknownType(type)
+      ) {
         return;
       }
 
       let messageId: MessageId | null = null;
-      if (isTypeFlagSet(type, ts.TypeFlags.Never)) {
+      if (ESLintUtils.isTypeFlagSet(type, ts.TypeFlags.Never)) {
         messageId = 'never';
       } else if (!isPossiblyNullish(type)) {
         messageId = 'neverNullish';
@@ -335,7 +333,7 @@ export default createRule<Options, MessageId>({
             flag |= NULL | UNDEFINED;
           }
 
-          return isTypeFlagSet(type, flag);
+          return ESLintUtils.isTypeFlagSet(type, flag);
         };
 
         if (
@@ -451,7 +449,12 @@ export default createRule<Options, MessageId>({
           return;
         }
         // Predicate is always necessary if it involves `any` or `unknown`
-        if (returnTypes.some(t => isTypeAnyType(t) || isTypeUnknownType(t))) {
+        if (
+          returnTypes.some(
+            t =>
+              ESLintUtils.isTypeAnyType(t) || ESLintUtils.isTypeUnknownType(t),
+          )
+        ) {
           return;
         }
         if (!returnTypes.some(isPossiblyFalsy)) {
@@ -510,10 +513,10 @@ export default createRule<Options, MessageId>({
           propertyType.value.toString(),
         );
         if (propType) {
-          return isNullableType(propType, { allowUndefined: true });
+          return ESLintUtils.isNullableType(propType, { allowUndefined: true });
         }
       }
-      const typeName = getTypeName(checker, propertyType);
+      const typeName = ESLintUtils.getTypeName(checker, propertyType);
       return !!(
         (typeName === 'string' &&
           checker.getIndexInfoOfType(objType, ts.IndexKind.String)) ||
@@ -546,10 +549,14 @@ export default createRule<Options, MessageId>({
             type,
             property.name,
           );
-          return propType && isNullableType(propType, { allowUndefined: true });
+          return (
+            propType &&
+            ESLintUtils.isNullableType(propType, { allowUndefined: true })
+          );
         });
         return (
-          !isOwnNullable && isNullableType(prevType, { allowUndefined: true })
+          !isOwnNullable &&
+          ESLintUtils.isNullableType(prevType, { allowUndefined: true })
         );
       }
       return false;
@@ -564,9 +571,10 @@ export default createRule<Options, MessageId>({
           ? !isNullableOriginFromPrev(node)
           : true;
       return (
-        isTypeAnyType(type) ||
-        isTypeUnknownType(type) ||
-        (isNullableType(type, { allowUndefined: true }) && isOwnNullable)
+        ESLintUtils.isTypeAnyType(type) ||
+        ESLintUtils.isTypeUnknownType(type) ||
+        (ESLintUtils.isNullableType(type, { allowUndefined: true }) &&
+          isOwnNullable)
       );
     }
 

packages/eslint-plugin/src/rules/no-unnecessary-type-assertion.ts

@@ -1,6 +1,7 @@
 import {
   TSESTree,
   AST_NODE_TYPES,
+  ESLintUtils,
 } from '@typescript-eslint/experimental-utils';
 import {
   isObjectType,
@@ -93,7 +94,7 @@ export default util.createRule<Options, MessageIds>({
      * Returns true if there's a chance the variable has been used before a value has been assigned to it
      */
     function isPossiblyUsedBeforeAssigned(node: ts.Expression): boolean {
-      const declaration = util.getDeclaration(checker, node);
+      const declaration = ESLintUtils.getDeclaration(checker, node);
       if (!declaration) {
         // don't know what the declaration is for some reason, so just assume the worst
         return true;
@@ -112,7 +113,7 @@ export default util.createRule<Options, MessageIds>({
       ) {
         // check if the defined variable type has changed since assignment
         const declarationType = checker.getTypeFromTypeNode(declaration.type);
-        const type = util.getConstrainedTypeAtLocation(checker, node);
+        const type = ESLintUtils.getConstrainedTypeAtLocation(checker, node);
         if (declarationType === type) {
           // possibly used before assigned, so just skip it
           // better to false negative and skip it, than false positive and fix to compile erroring code
@@ -160,12 +161,12 @@ export default util.createRule<Options, MessageIds>({
 
         const originalNode = parserServices.esTreeNodeToTSNodeMap.get(node);
 
-        const type = util.getConstrainedTypeAtLocation(
+        const type = ESLintUtils.getConstrainedTypeAtLocation(
           checker,
           originalNode.expression,
         );
 
-        if (!util.isNullableType(type)) {
+        if (!ESLintUtils.isNullableType(type)) {
           if (isPossiblyUsedBeforeAssigned(originalNode.expression)) {
             return;
           }
@@ -184,24 +185,27 @@ export default util.createRule<Options, MessageIds>({
           // we know it's a nullable type
           // so figure out if the variable is used in a place that accepts nullable types
 
-          const contextualType = util.getContextualType(checker, originalNode);
+          const contextualType = ESLintUtils.getContextualType(
+            checker,
+            originalNode,
+          );
           if (contextualType) {
             // in strict mode you can't assign null to undefined, so we have to make sure that
             // the two types share a nullable type
-            const typeIncludesUndefined = util.isTypeFlagSet(
+            const typeIncludesUndefined = ESLintUtils.isTypeFlagSet(
               type,
               ts.TypeFlags.Undefined,
             );
-            const typeIncludesNull = util.isTypeFlagSet(
+            const typeIncludesNull = ESLintUtils.isTypeFlagSet(
               type,
               ts.TypeFlags.Null,
             );
 
-            const contextualTypeIncludesUndefined = util.isTypeFlagSet(
+            const contextualTypeIncludesUndefined = ESLintUtils.isTypeFlagSet(
               contextualType,
               ts.TypeFlags.Undefined,
             );
-            const contextualTypeIncludesNull = util.isTypeFlagSet(
+            const contextualTypeIncludesNull = ESLintUtils.isTypeFlagSet(
               contextualType,
               ts.TypeFlags.Null,
             );