eslint-plugin-jest 25.7.0 → 26.1.0

package/lib/rules/require-hook.js

@@ -5,33 +5,33 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 
-var _experimentalUtils = require("@typescript-eslint/experimental-utils");
+var _utils = require("@typescript-eslint/utils");
 
-var _utils = require("./utils");
+var _utils2 = require("./utils");
 
 const isJestFnCall = node => {
   var _getNodeName;
 
-  if ((0, _utils.isDescribeCall)(node) || (0, _utils.isTestCaseCall)(node) || (0, _utils.isHook)(node)) {
+  if ((0, _utils2.isDescribeCall)(node) || (0, _utils2.isTestCaseCall)(node) || (0, _utils2.isHook)(node)) {
     return true;
   }
 
-  return !!((_getNodeName = (0, _utils.getNodeName)(node)) !== null && _getNodeName !== void 0 && _getNodeName.startsWith('jest.'));
+  return !!((_getNodeName = (0, _utils2.getNodeName)(node)) !== null && _getNodeName !== void 0 && _getNodeName.startsWith('jest.'));
 };
 
 const isNullOrUndefined = node => {
-  return node.type === _experimentalUtils.AST_NODE_TYPES.Literal && node.value === null || (0, _utils.isIdentifier)(node, 'undefined');
+  return node.type === _utils.AST_NODE_TYPES.Literal && node.value === null || (0, _utils2.isIdentifier)(node, 'undefined');
 };
 
 const shouldBeInHook = (node, allowedFunctionCalls = []) => {
   switch (node.type) {
-    case _experimentalUtils.AST_NODE_TYPES.ExpressionStatement:
+    case _utils.AST_NODE_TYPES.ExpressionStatement:
       return shouldBeInHook(node.expression, allowedFunctionCalls);
 
-    case _experimentalUtils.AST_NODE_TYPES.CallExpression:
-      return !(isJestFnCall(node) || allowedFunctionCalls.includes((0, _utils.getNodeName)(node)));
+    case _utils.AST_NODE_TYPES.CallExpression:
+      return !(isJestFnCall(node) || allowedFunctionCalls.includes((0, _utils2.getNodeName)(node)));
 
-    case _experimentalUtils.AST_NODE_TYPES.VariableDeclaration:
+    case _utils.AST_NODE_TYPES.VariableDeclaration:
       {
         if (node.kind === 'const') {
           return false;
@@ -47,7 +47,7 @@ const shouldBeInHook = (node, allowedFunctionCalls = []) => {
   }
 };
 
-var _default = (0, _utils.createRule)({
+var _default = (0, _utils2.createRule)({
   name: __filename,
   meta: {
     docs: {
@@ -100,13 +100,13 @@ var _default = (0, _utils.createRule)({
       },
 
       CallExpression(node) {
-        if (!(0, _utils.isDescribeCall)(node) || node.arguments.length < 2) {
+        if (!(0, _utils2.isDescribeCall)(node) || node.arguments.length < 2) {
           return;
         }
 
         const [, testFn] = node.arguments;
 
-        if (!(0, _utils.isFunction)(testFn) || testFn.body.type !== _experimentalUtils.AST_NODE_TYPES.BlockStatement) {
+        if (!(0, _utils2.isFunction)(testFn) || testFn.body.type !== _utils.AST_NODE_TYPES.BlockStatement) {
           return;
         }
 

package/lib/rules/utils.js

@@ -9,20 +9,20 @@ exports.scopeHasLocalReference = exports.parseExpectCall = exports.isTestCaseCal
 
 var _path = require("path");
 
-var _experimentalUtils = require("@typescript-eslint/experimental-utils");
+var _utils = require("@typescript-eslint/utils");
 
 var _package = require("../../package.json");
 
 const REPO_URL = 'https://github.com/jest-community/eslint-plugin-jest';
 
-const createRule = _experimentalUtils.ESLintUtils.RuleCreator(name => {
+const createRule = _utils.ESLintUtils.RuleCreator(name => {
   const ruleName = (0, _path.parse)(name).name;
   return `${REPO_URL}/blob/v${_package.version}/docs/rules/${ruleName}.md`;
 });
 
 exports.createRule = createRule;
 
-const isTypeCastExpression = node => node.type === _experimentalUtils.AST_NODE_TYPES.TSAsExpression || node.type === _experimentalUtils.AST_NODE_TYPES.TSTypeAssertion;
+const isTypeCastExpression = node => node.type === _utils.AST_NODE_TYPES.TSAsExpression || node.type === _utils.AST_NODE_TYPES.TSTypeAssertion;
 
 const followTypeAssertionChain = expression => isTypeCastExpression(expression) ? followTypeAssertionChain(expression.expression) : expression;
 /**
@@ -45,7 +45,7 @@ exports.followTypeAssertionChain = followTypeAssertionChain;
  *
  * @template V
  */
-const isStringLiteral = (node, value) => node.type === _experimentalUtils.AST_NODE_TYPES.Literal && typeof node.value === 'string' && (value === undefined || node.value === value);
+const isStringLiteral = (node, value) => node.type === _utils.AST_NODE_TYPES.Literal && typeof node.value === 'string' && (value === undefined || node.value === value);
 
 /**
  * Checks if the given `node` is a `TemplateLiteral`.
@@ -62,7 +62,7 @@ const isStringLiteral = (node, value) => node.type === _experimentalUtils.AST_NO
  *
  * @template V
  */
-const isTemplateLiteral = (node, value) => node.type === _experimentalUtils.AST_NODE_TYPES.TemplateLiteral && node.quasis.length === 1 && ( // bail out if not simple
+const isTemplateLiteral = (node, value) => node.type === _utils.AST_NODE_TYPES.TemplateLiteral && node.quasis.length === 1 && ( // bail out if not simple
 value === undefined || node.quasis[0].value.raw === value);
 
 /**
@@ -128,7 +128,7 @@ exports.hasOnlyOneArgument = hasOnlyOneArgument;
  *
  * @template V
  */
-const isIdentifier = (node, name) => node.type === _experimentalUtils.AST_NODE_TYPES.Identifier && (name === undefined || node.name === name);
+const isIdentifier = (node, name) => node.type === _utils.AST_NODE_TYPES.Identifier && (name === undefined || node.name === name);
 /**
  * Checks if the given `node` is a "supported accessor".
  *
@@ -170,7 +170,7 @@ const isSupportedAccessor = (node, value) => isIdentifier(node, value) || isStri
 
 exports.isSupportedAccessor = isSupportedAccessor;
 
-const getAccessorValue = accessor => accessor.type === _experimentalUtils.AST_NODE_TYPES.Identifier ? accessor.name : getStringValue(accessor);
+const getAccessorValue = accessor => accessor.type === _utils.AST_NODE_TYPES.Identifier ? accessor.name : getStringValue(accessor);
 
 exports.getAccessorValue = getAccessorValue;
 
@@ -186,11 +186,11 @@ exports.getAccessorValue = getAccessorValue;
  *
  * @return {node is ExpectCall}
  */
-const isExpectCall = node => node.type === _experimentalUtils.AST_NODE_TYPES.CallExpression && isSupportedAccessor(node.callee, 'expect') && node.parent !== undefined;
+const isExpectCall = node => node.type === _utils.AST_NODE_TYPES.CallExpression && isSupportedAccessor(node.callee, 'expect') && node.parent !== undefined;
 
 exports.isExpectCall = isExpectCall;
 
-const isExpectMember = (node, name) => node.type === _experimentalUtils.AST_NODE_TYPES.MemberExpression && isSupportedAccessor(node.property, name);
+const isExpectMember = (node, name) => node.type === _utils.AST_NODE_TYPES.MemberExpression && isSupportedAccessor(node.property, name);
 /**
  * Represents all the jest matchers.
  */
@@ -235,7 +235,7 @@ const reparseAsMatcher = parsedMember => ({ ...parsedMember,
    *
    * If this matcher isn't called, this will be `null`.
    */
-  arguments: parsedMember.node.parent.type === _experimentalUtils.AST_NODE_TYPES.CallExpression ? parsedMember.node.parent.arguments : null
+  arguments: parsedMember.node.parent.type === _utils.AST_NODE_TYPES.CallExpression ? parsedMember.node.parent.arguments : null
 });
 /**
  * Re-parses the given `parsedMember` as a `ParsedExpectModifier`.
@@ -366,25 +366,25 @@ function getNodeName(node) {
   }
 
   switch (node.type) {
-    case _experimentalUtils.AST_NODE_TYPES.TaggedTemplateExpression:
+    case _utils.AST_NODE_TYPES.TaggedTemplateExpression:
       return getNodeName(node.tag);
 
-    case _experimentalUtils.AST_NODE_TYPES.MemberExpression:
+    case _utils.AST_NODE_TYPES.MemberExpression:
       return joinNames(getNodeName(node.object), getNodeName(node.property));
 
-    case _experimentalUtils.AST_NODE_TYPES.NewExpression:
-    case _experimentalUtils.AST_NODE_TYPES.CallExpression:
+    case _utils.AST_NODE_TYPES.NewExpression:
+    case _utils.AST_NODE_TYPES.CallExpression:
       return getNodeName(node.callee);
   }
 
   return null;
 }
 
-const isFunction = node => node.type === _experimentalUtils.AST_NODE_TYPES.FunctionExpression || node.type === _experimentalUtils.AST_NODE_TYPES.ArrowFunctionExpression;
+const isFunction = node => node.type === _utils.AST_NODE_TYPES.FunctionExpression || node.type === _utils.AST_NODE_TYPES.ArrowFunctionExpression;
 
 exports.isFunction = isFunction;
 
-const isHook = node => node.callee.type === _experimentalUtils.AST_NODE_TYPES.Identifier && HookName.hasOwnProperty(node.callee.name);
+const isHook = node => node.callee.type === _utils.AST_NODE_TYPES.Identifier && HookName.hasOwnProperty(node.callee.name);
 
 exports.isHook = isHook;
 
@@ -393,12 +393,12 @@ const getTestCallExpressionsFromDeclaredVariables = declaredVariables => {
     references
   }) => acc.concat(references.map(({
     identifier
-  }) => identifier.parent).filter(node => !!node && node.type === _experimentalUtils.AST_NODE_TYPES.CallExpression && isTestCaseCall(node))), []);
+  }) => identifier.parent).filter(node => !!node && node.type === _utils.AST_NODE_TYPES.CallExpression && isTestCaseCall(node))), []);
 };
 
 exports.getTestCallExpressionsFromDeclaredVariables = getTestCallExpressionsFromDeclaredVariables;
 
-const isTestCaseName = node => node.type === _experimentalUtils.AST_NODE_TYPES.Identifier && TestCaseName.hasOwnProperty(node.name);
+const isTestCaseName = node => node.type === _utils.AST_NODE_TYPES.Identifier && TestCaseName.hasOwnProperty(node.name);
 
 const isTestCaseProperty = node => isSupportedAccessor(node) && TestCaseProperty.hasOwnProperty(getAccessorValue(node));
 /**
@@ -419,15 +419,15 @@ const isTestCaseCall = node => {
     return true;
   }
 
-  const callee = node.callee.type === _experimentalUtils.AST_NODE_TYPES.TaggedTemplateExpression ? node.callee.tag : node.callee.type === _experimentalUtils.AST_NODE_TYPES.CallExpression ? node.callee.callee : node.callee;
+  const callee = node.callee.type === _utils.AST_NODE_TYPES.TaggedTemplateExpression ? node.callee.tag : node.callee.type === _utils.AST_NODE_TYPES.CallExpression ? node.callee.callee : node.callee;
 
-  if (callee.type === _experimentalUtils.AST_NODE_TYPES.MemberExpression && isTestCaseProperty(callee.property)) {
+  if (callee.type === _utils.AST_NODE_TYPES.MemberExpression && isTestCaseProperty(callee.property)) {
     // if we're an `each()`, ensure we're the outer CallExpression (i.e `.each()()`)
-    if (getAccessorValue(callee.property) === 'each' && node.callee.type !== _experimentalUtils.AST_NODE_TYPES.TaggedTemplateExpression && node.callee.type !== _experimentalUtils.AST_NODE_TYPES.CallExpression) {
+    if (getAccessorValue(callee.property) === 'each' && node.callee.type !== _utils.AST_NODE_TYPES.TaggedTemplateExpression && node.callee.type !== _utils.AST_NODE_TYPES.CallExpression) {
       return false;
     }
 
-    return callee.object.type === _experimentalUtils.AST_NODE_TYPES.MemberExpression ? isTestCaseName(callee.object.object) : isTestCaseName(callee.object);
+    return callee.object.type === _utils.AST_NODE_TYPES.MemberExpression ? isTestCaseName(callee.object.object) : isTestCaseName(callee.object);
   }
 
   return false;
@@ -435,7 +435,7 @@ const isTestCaseCall = node => {
 
 exports.isTestCaseCall = isTestCaseCall;
 
-const isDescribeAlias = node => node.type === _experimentalUtils.AST_NODE_TYPES.Identifier && DescribeAlias.hasOwnProperty(node.name);
+const isDescribeAlias = node => node.type === _utils.AST_NODE_TYPES.Identifier && DescribeAlias.hasOwnProperty(node.name);
 
 const isDescribeProperty = node => isSupportedAccessor(node) && DescribeProperty.hasOwnProperty(getAccessorValue(node));
 /**
@@ -456,15 +456,15 @@ const isDescribeCall = node => {
     return true;
   }
 
-  const callee = node.callee.type === _experimentalUtils.AST_NODE_TYPES.TaggedTemplateExpression ? node.callee.tag : node.callee.type === _experimentalUtils.AST_NODE_TYPES.CallExpression ? node.callee.callee : node.callee;
+  const callee = node.callee.type === _utils.AST_NODE_TYPES.TaggedTemplateExpression ? node.callee.tag : node.callee.type === _utils.AST_NODE_TYPES.CallExpression ? node.callee.callee : node.callee;
 
-  if (callee.type === _experimentalUtils.AST_NODE_TYPES.MemberExpression && isDescribeProperty(callee.property)) {
+  if (callee.type === _utils.AST_NODE_TYPES.MemberExpression && isDescribeProperty(callee.property)) {
     // if we're an `each()`, ensure we're the outer CallExpression (i.e `.each()()`)
-    if (getAccessorValue(callee.property) === 'each' && node.callee.type !== _experimentalUtils.AST_NODE_TYPES.TaggedTemplateExpression && node.callee.type !== _experimentalUtils.AST_NODE_TYPES.CallExpression) {
+    if (getAccessorValue(callee.property) === 'each' && node.callee.type !== _utils.AST_NODE_TYPES.TaggedTemplateExpression && node.callee.type !== _utils.AST_NODE_TYPES.CallExpression) {
       return false;
     }
 
-    return callee.object.type === _experimentalUtils.AST_NODE_TYPES.MemberExpression ? isDescribeAlias(callee.object.object) : isDescribeAlias(callee.object);
+    return callee.object.type === _utils.AST_NODE_TYPES.MemberExpression ? isDescribeAlias(callee.object.object) : isDescribeAlias(callee.object);
   }
 
   return false;

package/lib/rules/valid-describe-callback.js

@@ -5,9 +5,9 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 
-var _experimentalUtils = require("@typescript-eslint/experimental-utils");
+var _utils = require("@typescript-eslint/utils");
 
-var _utils = require("./utils");
+var _utils2 = require("./utils");
 
 const paramsLocation = params => {
   const [first] = params;
@@ -18,7 +18,7 @@ const paramsLocation = params => {
   };
 };
 
-var _default = (0, _utils.createRule)({
+var _default = (0, _utils2.createRule)({
   name: __filename,
   meta: {
     type: 'problem',
@@ -41,7 +41,7 @@ var _default = (0, _utils.createRule)({
   create(context) {
     return {
       CallExpression(node) {
-        if (!(0, _utils.isDescribeCall)(node)) {
+        if (!(0, _utils2.isDescribeCall)(node)) {
           return;
         }
 
@@ -62,7 +62,7 @@ var _default = (0, _utils.createRule)({
           return;
         }
 
-        if (!(0, _utils.isFunction)(callback)) {
+        if (!(0, _utils2.isFunction)(callback)) {
           context.report({
             messageId: 'secondArgumentMustBeFunction',
             loc: paramsLocation(node.arguments)
@@ -77,23 +77,23 @@ var _default = (0, _utils.createRule)({
           });
         }
 
-        if (!(0, _utils.getNodeName)(node).endsWith('each') && callback.params.length) {
+        if (!(0, _utils2.getNodeName)(node).endsWith('each') && callback.params.length) {
           context.report({
             messageId: 'unexpectedDescribeArgument',
             loc: paramsLocation(callback.params)
           });
         }
 
-        if (callback.body.type === _experimentalUtils.AST_NODE_TYPES.CallExpression) {
+        if (callback.body.type === _utils.AST_NODE_TYPES.CallExpression) {
           context.report({
             messageId: 'unexpectedReturnInDescribe',
             node: callback
           });
         }
 
-        if (callback.body.type === _experimentalUtils.AST_NODE_TYPES.BlockStatement) {
+        if (callback.body.type === _utils.AST_NODE_TYPES.BlockStatement) {
           callback.body.body.forEach(node => {
-            if (node.type === _experimentalUtils.AST_NODE_TYPES.ReturnStatement) {
+            if (node.type === _utils.AST_NODE_TYPES.ReturnStatement) {
               context.report({
                 messageId: 'unexpectedReturnInDescribe',
                 node

package/lib/rules/valid-expect-in-promise.js

@@ -5,18 +5,18 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 
-var _experimentalUtils = require("@typescript-eslint/experimental-utils");
+var _utils = require("@typescript-eslint/utils");
 
-var _utils = require("./utils");
+var _utils2 = require("./utils");
 
 const isPromiseChainCall = node => {
-  if (node.type === _experimentalUtils.AST_NODE_TYPES.CallExpression && node.callee.type === _experimentalUtils.AST_NODE_TYPES.MemberExpression && (0, _utils.isSupportedAccessor)(node.callee.property)) {
+  if (node.type === _utils.AST_NODE_TYPES.CallExpression && node.callee.type === _utils.AST_NODE_TYPES.MemberExpression && (0, _utils2.isSupportedAccessor)(node.callee.property)) {
     // promise methods should have at least 1 argument
     if (node.arguments.length === 0) {
       return false;
     }
 
-    switch ((0, _utils.getAccessorValue)(node.callee.property)) {
+    switch ((0, _utils2.getAccessorValue)(node.callee.property)) {
       case 'then':
         return node.arguments.length < 3;
 
@@ -36,13 +36,13 @@ const findTopMostCallExpression = node => {
   } = node;
 
   while (parent) {
-    if (parent.type === _experimentalUtils.AST_NODE_TYPES.CallExpression) {
+    if (parent.type === _utils.AST_NODE_TYPES.CallExpression) {
       topMostCallExpression = parent;
       parent = parent.parent;
       continue;
     }
 
-    if (parent.type !== _experimentalUtils.AST_NODE_TYPES.MemberExpression) {
+    if (parent.type !== _utils.AST_NODE_TYPES.MemberExpression) {
       break;
     }
 
@@ -53,13 +53,13 @@ const findTopMostCallExpression = node => {
 };
 
 const isTestCaseCallWithCallbackArg = node => {
-  if (!(0, _utils.isTestCaseCall)(node)) {
+  if (!(0, _utils2.isTestCaseCall)(node)) {
     return false;
   }
 
-  const isJestEach = (0, _utils.getNodeName)(node).endsWith('.each');
+  const isJestEach = (0, _utils2.getNodeName)(node).endsWith('.each');
 
-  if (isJestEach && node.callee.type !== _experimentalUtils.AST_NODE_TYPES.TaggedTemplateExpression) {
+  if (isJestEach && node.callee.type !== _utils.AST_NODE_TYPES.TaggedTemplateExpression) {
     // isJestEach but not a TaggedTemplateExpression, so this must be
     // the `jest.each([])()` syntax which this rule doesn't support due
     // to its complexity (see jest-community/eslint-plugin-jest#710)
@@ -70,7 +70,7 @@ const isTestCaseCallWithCallbackArg = node => {
   if (isJestEach || node.arguments.length >= 2) {
     const [, callback] = node.arguments;
     const callbackArgIndex = Number(isJestEach);
-    return callback && (0, _utils.isFunction)(callback) && callback.params.length === 1 + callbackArgIndex;
+    return callback && (0, _utils2.isFunction)(callback) && callback.params.length === 1 + callbackArgIndex;
   }
 
   return false;
@@ -85,23 +85,23 @@ const isPromiseMethodThatUsesValue = (node, identifier) => {
     return false;
   }
 
-  if (node.argument.type === _experimentalUtils.AST_NODE_TYPES.CallExpression && node.argument.arguments.length > 0) {
-    const nodeName = (0, _utils.getNodeName)(node.argument);
+  if (node.argument.type === _utils.AST_NODE_TYPES.CallExpression && node.argument.arguments.length > 0) {
+    const nodeName = (0, _utils2.getNodeName)(node.argument);
 
     if (['Promise.all', 'Promise.allSettled'].includes(nodeName)) {
       const [firstArg] = node.argument.arguments;
 
-      if (firstArg.type === _experimentalUtils.AST_NODE_TYPES.ArrayExpression && firstArg.elements.some(nod => (0, _utils.isIdentifier)(nod, name))) {
+      if (firstArg.type === _utils.AST_NODE_TYPES.ArrayExpression && firstArg.elements.some(nod => (0, _utils2.isIdentifier)(nod, name))) {
         return true;
       }
     }
 
     if (['Promise.resolve', 'Promise.reject'].includes(nodeName) && node.argument.arguments.length === 1) {
-      return (0, _utils.isIdentifier)(node.argument.arguments[0], name);
+      return (0, _utils2.isIdentifier)(node.argument.arguments[0], name);
     }
   }
 
-  return (0, _utils.isIdentifier)(node.argument, name);
+  return (0, _utils2.isIdentifier)(node.argument, name);
 };
 /**
  * Attempts to determine if the runtime value represented by the given `identifier`
@@ -111,11 +111,11 @@ const isPromiseMethodThatUsesValue = (node, identifier) => {
 
 const isValueAwaitedInElements = (name, elements) => {
   for (const element of elements) {
-    if (element.type === _experimentalUtils.AST_NODE_TYPES.AwaitExpression && (0, _utils.isIdentifier)(element.argument, name)) {
+    if (element.type === _utils.AST_NODE_TYPES.AwaitExpression && (0, _utils2.isIdentifier)(element.argument, name)) {
       return true;
     }
 
-    if (element.type === _experimentalUtils.AST_NODE_TYPES.ArrayExpression && isValueAwaitedInElements(name, element.elements)) {
+    if (element.type === _utils.AST_NODE_TYPES.ArrayExpression && isValueAwaitedInElements(name, element.elements)) {
       return true;
     }
   }
@@ -132,7 +132,7 @@ const isValueAwaitedInArguments = (name, call) => {
   let node = call;
 
   while (node) {
-    if (node.type === _experimentalUtils.AST_NODE_TYPES.CallExpression) {
+    if (node.type === _utils.AST_NODE_TYPES.CallExpression) {
       if (isValueAwaitedInElements(name, node.arguments)) {
         return true;
       }
@@ -140,7 +140,7 @@ const isValueAwaitedInArguments = (name, call) => {
       node = node.callee;
     }
 
-    if (node.type !== _experimentalUtils.AST_NODE_TYPES.MemberExpression) {
+    if (node.type !== _utils.AST_NODE_TYPES.MemberExpression) {
       break;
     }
 
@@ -155,12 +155,12 @@ const getLeftMostCallExpression = call => {
   let node = call;
 
   while (node) {
-    if (node.type === _experimentalUtils.AST_NODE_TYPES.CallExpression) {
+    if (node.type === _utils.AST_NODE_TYPES.CallExpression) {
       leftMostCallExpression = node;
       node = node.callee;
     }
 
-    if (node.type !== _experimentalUtils.AST_NODE_TYPES.MemberExpression) {
+    if (node.type !== _utils.AST_NODE_TYPES.MemberExpression) {
       break;
     }
 
@@ -187,42 +187,42 @@ const isValueAwaitedOrReturned = (identifier, body) => {
       continue;
     }
 
-    if (node.type === _experimentalUtils.AST_NODE_TYPES.ReturnStatement) {
+    if (node.type === _utils.AST_NODE_TYPES.ReturnStatement) {
       return isPromiseMethodThatUsesValue(node, identifier);
     }
 
-    if (node.type === _experimentalUtils.AST_NODE_TYPES.ExpressionStatement) {
+    if (node.type === _utils.AST_NODE_TYPES.ExpressionStatement) {
       // it's possible that we're awaiting the value as an argument
-      if (node.expression.type === _experimentalUtils.AST_NODE_TYPES.CallExpression) {
+      if (node.expression.type === _utils.AST_NODE_TYPES.CallExpression) {
         if (isValueAwaitedInArguments(name, node.expression)) {
           return true;
         }
 
         const leftMostCall = getLeftMostCallExpression(node.expression);
 
-        if ((0, _utils.isExpectCall)(leftMostCall) && leftMostCall.arguments.length > 0 && (0, _utils.isIdentifier)(leftMostCall.arguments[0], name)) {
+        if ((0, _utils2.isExpectCall)(leftMostCall) && leftMostCall.arguments.length > 0 && (0, _utils2.isIdentifier)(leftMostCall.arguments[0], name)) {
           const {
             modifier
-          } = (0, _utils.parseExpectCall)(leftMostCall);
+          } = (0, _utils2.parseExpectCall)(leftMostCall);
 
-          if ((modifier === null || modifier === void 0 ? void 0 : modifier.name) === _utils.ModifierName.resolves || (modifier === null || modifier === void 0 ? void 0 : modifier.name) === _utils.ModifierName.rejects) {
+          if ((modifier === null || modifier === void 0 ? void 0 : modifier.name) === _utils2.ModifierName.resolves || (modifier === null || modifier === void 0 ? void 0 : modifier.name) === _utils2.ModifierName.rejects) {
             return true;
           }
         }
       }
 
-      if (node.expression.type === _experimentalUtils.AST_NODE_TYPES.AwaitExpression && isPromiseMethodThatUsesValue(node.expression, identifier)) {
+      if (node.expression.type === _utils.AST_NODE_TYPES.AwaitExpression && isPromiseMethodThatUsesValue(node.expression, identifier)) {
         return true;
       } // (re)assignment changes the runtime value, so if we've not found an
       // await or return already we act as if we've reached the end of the body
 
 
-      if (node.expression.type === _experimentalUtils.AST_NODE_TYPES.AssignmentExpression) {
+      if (node.expression.type === _utils.AST_NODE_TYPES.AssignmentExpression) {
         var _getNodeName;
 
         // unless we're assigning to the same identifier, in which case
         // we might be chaining off the existing promise value
-        if ((0, _utils.isIdentifier)(node.expression.left, name) && (_getNodeName = (0, _utils.getNodeName)(node.expression.right)) !== null && _getNodeName !== void 0 && _getNodeName.startsWith(`${name}.`) && isPromiseChainCall(node.expression.right)) {
+        if ((0, _utils2.isIdentifier)(node.expression.left, name) && (_getNodeName = (0, _utils2.getNodeName)(node.expression.right)) !== null && _getNodeName !== void 0 && _getNodeName.startsWith(`${name}.`) && isPromiseChainCall(node.expression.right)) {
           continue;
         }
 
@@ -230,7 +230,7 @@ const isValueAwaitedOrReturned = (identifier, body) => {
       }
     }
 
-    if (node.type === _experimentalUtils.AST_NODE_TYPES.BlockStatement && isValueAwaitedOrReturned(identifier, node.body)) {
+    if (node.type === _utils.AST_NODE_TYPES.BlockStatement && isValueAwaitedOrReturned(identifier, node.body)) {
       return true;
     }
   }
@@ -242,7 +242,7 @@ const findFirstBlockBodyUp = node => {
   let parent = node;
 
   while (parent) {
-    if (parent.type === _experimentalUtils.AST_NODE_TYPES.BlockStatement) {
+    if (parent.type === _utils.AST_NODE_TYPES.BlockStatement) {
       return parent.body;
     }
 
@@ -258,11 +258,11 @@ const isDirectlyWithinTestCaseCall = node => {
   let parent = node;
 
   while (parent) {
-    if ((0, _utils.isFunction)(parent)) {
+    if ((0, _utils2.isFunction)(parent)) {
       var _parent;
 
       parent = parent.parent;
-      return !!(((_parent = parent) === null || _parent === void 0 ? void 0 : _parent.type) === _experimentalUtils.AST_NODE_TYPES.CallExpression && (0, _utils.isTestCaseCall)(parent));
+      return !!(((_parent = parent) === null || _parent === void 0 ? void 0 : _parent.type) === _utils.AST_NODE_TYPES.CallExpression && (0, _utils2.isTestCaseCall)(parent));
     }
 
     parent = parent.parent;
@@ -275,14 +275,14 @@ const isVariableAwaitedOrReturned = variable => {
   const body = findFirstBlockBodyUp(variable); // it's pretty much impossible for us to track destructuring assignments,
   // so we return true to bailout gracefully
 
-  if (!(0, _utils.isIdentifier)(variable.id)) {
+  if (!(0, _utils2.isIdentifier)(variable.id)) {
     return true;
   }
 
   return isValueAwaitedOrReturned(variable.id, body);
 };
 
-var _default = (0, _utils.createRule)({
+var _default = (0, _utils2.createRule)({
   name: __filename,
   meta: {
     docs: {
@@ -326,7 +326,7 @@ var _default = (0, _utils.createRule)({
         // an expect call, mark the deepest chain as having an expect call
 
 
-        if (chains.length > 0 && (0, _utils.isExpectCall)(node)) {
+        if (chains.length > 0 && (0, _utils2.isExpectCall)(node)) {
           chains[0] = true;
         }
       },
@@ -336,7 +336,7 @@ var _default = (0, _utils.createRule)({
         // make promises containing expects safe in a test for us to be able to
         // accurately check, so we just bail out completely if it's present
         if (inTestCaseWithDoneCallback) {
-          if ((0, _utils.isTestCaseCall)(node)) {
+          if ((0, _utils2.isTestCaseCall)(node)) {
             inTestCaseWithDoneCallback = false;
           }
 
@@ -368,7 +368,7 @@ var _default = (0, _utils.createRule)({
         }
 
         switch (parent.type) {
-          case _experimentalUtils.AST_NODE_TYPES.VariableDeclarator:
+          case _utils.AST_NODE_TYPES.VariableDeclarator:
             {
               if (isVariableAwaitedOrReturned(parent)) {
                 return;
@@ -377,20 +377,20 @@ var _default = (0, _utils.createRule)({
               break;
             }
 
-          case _experimentalUtils.AST_NODE_TYPES.AssignmentExpression:
+          case _utils.AST_NODE_TYPES.AssignmentExpression:
             {
-              if (parent.left.type === _experimentalUtils.AST_NODE_TYPES.Identifier && isValueAwaitedOrReturned(parent.left, findFirstBlockBodyUp(parent))) {
+              if (parent.left.type === _utils.AST_NODE_TYPES.Identifier && isValueAwaitedOrReturned(parent.left, findFirstBlockBodyUp(parent))) {
                 return;
               }
 
               break;
             }
 
-          case _experimentalUtils.AST_NODE_TYPES.ExpressionStatement:
+          case _utils.AST_NODE_TYPES.ExpressionStatement:
             break;
 
-          case _experimentalUtils.AST_NODE_TYPES.ReturnStatement:
-          case _experimentalUtils.AST_NODE_TYPES.AwaitExpression:
+          case _utils.AST_NODE_TYPES.ReturnStatement:
+          case _utils.AST_NODE_TYPES.AwaitExpression:
           default:
             return;
         }