eslint-plugin-jest 26.7.0 → 26.8.0

package/lib/rules/max-expects.js

@@ -56,7 +56,7 @@ var _default = (0, _utils2.createRule)({
       ArrowFunctionExpression: onFunctionExpressionEnter,
 
       CallExpression(node) {
-        if (!(0, _utils2.isExpectCall)(node)) {
+        if (!(0, _utils2.isTypeOfJestFnCall)(node, context, ['expect'])) {
           return;
         }
 

package/lib/rules/no-alias-methods.js

@@ -41,19 +41,16 @@ var _default = (0, _utils.createRule)({
     };
     return {
       CallExpression(node) {
-        if (!(0, _utils.isExpectCall)(node)) {
+        const jestFnCall = (0, _utils.parseJestFnCall)(node, context);
+
+        if ((jestFnCall === null || jestFnCall === void 0 ? void 0 : jestFnCall.type) !== 'expect') {
           return;
         }
 
         const {
           matcher
-        } = (0, _utils.parseExpectCall)(node);
-
-        if (!matcher) {
-          return;
-        }
-
-        const alias = matcher.name;
+        } = jestFnCall;
+        const alias = (0, _utils.getAccessorValue)(matcher);
 
         if (alias in methodNames) {
           const canonical = methodNames[alias];
@@ -63,8 +60,8 @@ var _default = (0, _utils.createRule)({
               alias,
               canonical
             },
-            node: matcher.node.property,
-            fix: fixer => [(0, _utils.replaceAccessorFixer)(fixer, matcher.node.property, canonical)]
+            node: matcher,
+            fix: fixer => [(0, _utils.replaceAccessorFixer)(fixer, matcher, canonical)]
           });
         }
       }

package/lib/rules/no-conditional-expect.js

@@ -47,7 +47,13 @@ var _default = (0, _utils2.createRule)({
       },
 
       CallExpression(node) {
-        if ((0, _utils2.isTypeOfJestFnCall)(node, context, ['test'])) {
+        var _parseJestFnCall;
+
+        const {
+          type: jestFnCallType
+        } = (_parseJestFnCall = (0, _utils2.parseJestFnCall)(node, context)) !== null && _parseJestFnCall !== void 0 ? _parseJestFnCall : {};
+
+        if (jestFnCallType === 'test') {
           inTestCase = true;
         }
 
@@ -55,14 +61,14 @@ var _default = (0, _utils2.createRule)({
           inPromiseCatch = true;
         }
 
-        if (inTestCase && (0, _utils2.isExpectCall)(node) && conditionalDepth > 0) {
+        if (inTestCase && jestFnCallType === 'expect' && conditionalDepth > 0) {
           context.report({
             messageId: 'conditionalExpect',
             node
           });
         }
 
-        if (inPromiseCatch && (0, _utils2.isExpectCall)(node)) {
+        if (inPromiseCatch && jestFnCallType === 'expect') {
           context.report({
             messageId: 'conditionalExpect',
             node

package/lib/rules/no-interpolation-in-snapshots.js

@@ -28,23 +28,15 @@ var _default = (0, _utils2.createRule)({
   create(context) {
     return {
       CallExpression(node) {
-        if (!(0, _utils2.isExpectCall)(node)) {
-          return;
-        }
+        const jestFnCall = (0, _utils2.parseJestFnCall)(node, context);
 
-        const {
-          matcher
-        } = (0, _utils2.parseExpectCall)(node);
-
-        if (!matcher) {
+        if ((jestFnCall === null || jestFnCall === void 0 ? void 0 : jestFnCall.type) !== 'expect') {
           return;
         }
 
-        if (['toMatchInlineSnapshot', 'toThrowErrorMatchingInlineSnapshot'].includes(matcher.name)) {
-          var _matcher$arguments;
-
+        if (['toMatchInlineSnapshot', 'toThrowErrorMatchingInlineSnapshot'].includes((0, _utils2.getAccessorValue)(jestFnCall.matcher))) {
           // Check all since the optional 'propertyMatchers' argument might be present
-          (_matcher$arguments = matcher.arguments) === null || _matcher$arguments === void 0 ? void 0 : _matcher$arguments.forEach(argument => {
+          jestFnCall.args.forEach(argument => {
             if (argument.type === _utils.AST_NODE_TYPES.TemplateLiteral && argument.expressions.length > 0) {
               context.report({
                 messageId: 'noInterpolation',

package/lib/rules/no-large-snapshots.js

@@ -26,7 +26,7 @@ const reportOnViolation = (context, node, {
 
   let isAllowed = false;
 
-  if (node.type === _utils.AST_NODE_TYPES.ExpressionStatement && 'left' in node.expression && (0, _utils2.isExpectMember)(node.expression.left)) {
+  if (node.type === _utils.AST_NODE_TYPES.ExpressionStatement && 'left' in node.expression && node.expression.left.type === _utils.AST_NODE_TYPES.MemberExpression && (0, _utils2.isSupportedAccessor)(node.expression.left.property)) {
     const fileName = context.getFilename();
     const allowedSnapshotsInFile = allowedSnapshots[fileName];
 
@@ -100,24 +100,16 @@ var _default = (0, _utils2.createRule)({
 
     return {
       CallExpression(node) {
-        var _matcher$arguments;
+        const jestFnCall = (0, _utils2.parseJestFnCall)(node, context);
 
-        if (!(0, _utils2.isExpectCall)(node)) {
+        if ((jestFnCall === null || jestFnCall === void 0 ? void 0 : jestFnCall.type) !== 'expect') {
           return;
         }
 
-        const {
-          matcher
-        } = (0, _utils2.parseExpectCall)(node);
-
-        if ((matcher === null || matcher === void 0 ? void 0 : matcher.node.parent.type) !== _utils.AST_NODE_TYPES.CallExpression) {
-          return;
-        }
-
-        if (['toMatchInlineSnapshot', 'toThrowErrorMatchingInlineSnapshot'].includes(matcher.name) && (_matcher$arguments = matcher.arguments) !== null && _matcher$arguments !== void 0 && _matcher$arguments.length) {
+        if (['toMatchInlineSnapshot', 'toThrowErrorMatchingInlineSnapshot'].includes((0, _utils2.getAccessorValue)(jestFnCall.matcher)) && jestFnCall.args.length) {
           var _options$inlineMaxSiz;
 
-          reportOnViolation(context, matcher.arguments[0], { ...options,
+          reportOnViolation(context, jestFnCall.args[0], { ...options,
             maxSize: (_options$inlineMaxSiz = options.inlineMaxSize) !== null && _options$inlineMaxSiz !== void 0 ? _options$inlineMaxSiz : options.maxSize
           });
         }

package/lib/rules/no-restricted-matchers.js

@@ -30,65 +30,43 @@ var _default = (0, _utils.createRule)({
   defaultOptions: [{}],
 
   create(context, [restrictedChains]) {
-    const reportIfRestricted = (loc, chain) => {
-      if (!(chain in restrictedChains)) {
-        return false;
-      }
-
-      const message = restrictedChains[chain];
-      context.report({
-        messageId: message ? 'restrictedChainWithMessage' : 'restrictedChain',
-        data: {
-          message,
-          chain
-        },
-        loc
-      });
-      return true;
-    };
-
     return {
       CallExpression(node) {
-        if (!(0, _utils.isExpectCall)(node)) {
-          return;
-        }
+        const jestFnCall = (0, _utils.parseJestFnCall)(node, context);
 
-        const {
-          matcher,
-          modifier
-        } = (0, _utils.parseExpectCall)(node);
-
-        if (matcher && reportIfRestricted(matcher.node.property.loc, matcher.name)) {
+        if ((jestFnCall === null || jestFnCall === void 0 ? void 0 : jestFnCall.type) !== 'expect') {
           return;
         }
 
-        if (modifier) {
-          if (reportIfRestricted(modifier.node.property.loc, modifier.name)) {
-            return;
-          }
+        const permutations = [jestFnCall.members];
 
-          if (modifier.negation) {
-            if (reportIfRestricted(modifier.negation.property.loc, 'not') || reportIfRestricted({
-              start: modifier.node.property.loc.start,
-              end: modifier.negation.property.loc.end
-            }, `${modifier.name}.not`)) {
-              return;
-            }
-          }
+        if (jestFnCall.members.length > 2) {
+          permutations.push([jestFnCall.members[0], jestFnCall.members[1]]);
+          permutations.push([jestFnCall.members[1], jestFnCall.members[2]]);
         }
 
-        if (matcher && modifier) {
-          let chain = modifier.name;
+        if (jestFnCall.members.length > 1) {
+          permutations.push(...jestFnCall.members.map(nod => [nod]));
+        }
 
-          if (modifier.negation) {
-            chain += '.not';
+        for (const permutation of permutations) {
+          const chain = permutation.map(nod => (0, _utils.getAccessorValue)(nod)).join('.');
+
+          if (chain in restrictedChains) {
+            const message = restrictedChains[chain];
+            context.report({
+              messageId: message ? 'restrictedChainWithMessage' : 'restrictedChain',
+              data: {
+                message,
+                chain
+              },
+              loc: {
+                start: permutation[0].loc.start,
+                end: permutation[permutation.length - 1].loc.end
+              }
+            });
+            break;
           }
-
-          chain += `.${matcher.name}`;
-          reportIfRestricted({
-            start: modifier.node.property.loc.start,
-            end: matcher.node.property.loc.end
-          }, chain);
         }
       }
 

package/lib/rules/no-standalone-expect.js

@@ -73,11 +73,15 @@ var _default = (0, _utils2.createRule)({
 
     const isCustomTestBlockFunction = node => additionalTestBlockFunctions.includes((0, _utils2.getNodeName)(node) || '');
 
-    const isTestBlock = node => (0, _utils2.isTypeOfJestFnCall)(node, context, ['test']) || isCustomTestBlockFunction(node);
-
     return {
       CallExpression(node) {
-        if ((0, _utils2.isExpectCall)(node)) {
+        var _parseJestFnCall;
+
+        const {
+          type: jestFnCallType
+        } = (_parseJestFnCall = (0, _utils2.parseJestFnCall)(node, context)) !== null && _parseJestFnCall !== void 0 ? _parseJestFnCall : {};
+
+        if (jestFnCallType === 'expect') {
           const parent = callStack[callStack.length - 1];
 
           if (!parent || parent === _utils2.DescribeAlias.describe) {
@@ -90,7 +94,7 @@ var _default = (0, _utils2.createRule)({
           return;
         }
 
-        if (isTestBlock(node)) {
+        if (jestFnCallType === 'test' || isCustomTestBlockFunction(node)) {
           callStack.push('test');
         }
 
@@ -102,7 +106,7 @@ var _default = (0, _utils2.createRule)({
       'CallExpression:exit'(node) {
         const top = callStack[callStack.length - 1];
 
-        if (top === 'test' && isTestBlock(node) && node.callee.type !== _utils.AST_NODE_TYPES.MemberExpression || top === 'template' && node.callee.type === _utils.AST_NODE_TYPES.TaggedTemplateExpression) {
+        if (top === 'test' && ((0, _utils2.isTypeOfJestFnCall)(node, context, ['test']) || isCustomTestBlockFunction(node)) && node.callee.type !== _utils.AST_NODE_TYPES.MemberExpression || top === 'template' && node.callee.type === _utils.AST_NODE_TYPES.TaggedTemplateExpression) {
           callStack.pop();
         }
       },

package/lib/rules/prefer-called-with.js

@@ -26,26 +26,28 @@ var _default = (0, _utils.createRule)({
   create(context) {
     return {
       CallExpression(node) {
-        if (!(0, _utils.isExpectCall)(node)) {
+        const jestFnCall = (0, _utils.parseJestFnCall)(node, context);
+
+        if ((jestFnCall === null || jestFnCall === void 0 ? void 0 : jestFnCall.type) !== 'expect') {
           return;
         }
 
-        const {
-          modifier,
-          matcher
-        } = (0, _utils.parseExpectCall)(node);
-
-        if (!matcher || (modifier === null || modifier === void 0 ? void 0 : modifier.name) === _utils.ModifierName.not || modifier !== null && modifier !== void 0 && modifier.negation) {
+        if (jestFnCall.modifiers.some(nod => (0, _utils.getAccessorValue)(nod) === 'not')) {
           return;
         }
 
-        if (['toBeCalled', 'toHaveBeenCalled'].includes(matcher.name)) {
+        const {
+          matcher
+        } = jestFnCall;
+        const matcherName = (0, _utils.getAccessorValue)(matcher);
+
+        if (['toBeCalled', 'toHaveBeenCalled'].includes(matcherName)) {
           context.report({
             data: {
-              matcherName: matcher.name
+              matcherName
             },
             messageId: 'preferCalledWith',
-            node: matcher.node.property
+            node: matcher
           });
         }
       }

package/lib/rules/prefer-comparison-matcher.js

@@ -9,22 +9,6 @@ var _utils = require("@typescript-eslint/utils");
 
 var _utils2 = require("./utils");
 
-const isBooleanLiteral = node => node.type === _utils.AST_NODE_TYPES.Literal && typeof node.value === 'boolean';
-
-/**
- * Checks if the given `ParsedExpectMatcher` is a call to one of the equality matchers,
- * with a boolean literal as the sole argument.
- *
- * @example javascript
- * toBe(true);
- * toEqual(false);
- *
- * @param {ParsedExpectMatcher} matcher
- *
- * @return {matcher is ParsedBooleanEqualityMatcher}
- */
-const isBooleanEqualityMatcher = matcher => (0, _utils2.isParsedEqualityMatcherCall)(matcher) && isBooleanLiteral((0, _utils2.followTypeAssertionChain)(matcher.arguments[0]));
-
 const isString = node => {
   return (0, _utils2.isStringNode)(node) || node.type === _utils.AST_NODE_TYPES.TemplateLiteral;
 };
@@ -91,27 +75,36 @@ var _default = (0, _utils2.createRule)({
   create(context) {
     return {
       CallExpression(node) {
-        if (!(0, _utils2.isExpectCall)(node)) {
+        const jestFnCall = (0, _utils2.parseJestFnCall)(node, context);
+
+        if ((jestFnCall === null || jestFnCall === void 0 ? void 0 : jestFnCall.type) !== 'expect' || jestFnCall.args.length === 0) {
           return;
         }
 
         const {
-          expect: {
-            arguments: [comparison],
-            range: [, expectCallEnd]
-          },
-          matcher,
-          modifier
-        } = (0, _utils2.parseExpectCall)(node);
+          parent: expect
+        } = jestFnCall.head.node;
+
+        if ((expect === null || expect === void 0 ? void 0 : expect.type) !== _utils.AST_NODE_TYPES.CallExpression) {
+          return;
+        }
+
+        const {
+          arguments: [comparison],
+          range: [, expectCallEnd]
+        } = expect;
+        const {
+          matcher
+        } = jestFnCall;
+        const matcherArg = (0, _utils2.getFirstMatcherArg)(jestFnCall);
 
-        if (!matcher || (comparison === null || comparison === void 0 ? void 0 : comparison.type) !== _utils.AST_NODE_TYPES.BinaryExpression || isComparingToString(comparison) || !isBooleanEqualityMatcher(matcher)) {
+        if ((comparison === null || comparison === void 0 ? void 0 : comparison.type) !== _utils.AST_NODE_TYPES.BinaryExpression || isComparingToString(comparison) || !_utils2.EqualityMatcher.hasOwnProperty((0, _utils2.getAccessorValue)(matcher)) || !(0, _utils2.isBooleanLiteral)(matcherArg)) {
           return;
         }
 
-        const negation = modifier !== null && modifier !== void 0 && modifier.negation ? {
-          node: modifier.negation
-        } : (modifier === null || modifier === void 0 ? void 0 : modifier.name) === _utils2.ModifierName.not ? modifier : null;
-        const preferredMatcher = determineMatcher(comparison.operator, (0, _utils2.followTypeAssertionChain)(matcher.arguments[0]).value === !!negation);
+        const [modifier] = jestFnCall.modifiers;
+        const hasNot = jestFnCall.modifiers.some(nod => (0, _utils2.getAccessorValue)(nod) === 'not');
+        const preferredMatcher = determineMatcher(comparison.operator, matcherArg.value === hasNot);
 
         if (!preferredMatcher) {
           return;
@@ -121,18 +114,18 @@ var _default = (0, _utils2.createRule)({
           fix(fixer) {
             const sourceCode = context.getSourceCode(); // preserve the existing modifier if it's not a negation
 
-            const modifierText = modifier && (modifier === null || modifier === void 0 ? void 0 : modifier.node) !== (negation === null || negation === void 0 ? void 0 : negation.node) ? `.${modifier.name}` : '';
+            const modifierText = modifier && (0, _utils2.getAccessorValue)(modifier) !== 'not' ? `.${(0, _utils2.getAccessorValue)(modifier)}` : '';
             return [// replace the comparison argument with the left-hand side of the comparison
             fixer.replaceText(comparison, sourceCode.getText(comparison.left)), // replace the current matcher & modifier with the preferred matcher
-            fixer.replaceTextRange([expectCallEnd, matcher.node.range[1]], `${modifierText}.${preferredMatcher}`), // replace the matcher argument with the right-hand side of the comparison
-            fixer.replaceText(matcher.arguments[0], sourceCode.getText(comparison.right))];
+            fixer.replaceTextRange([expectCallEnd, matcher.parent.range[1]], `${modifierText}.${preferredMatcher}`), // replace the matcher argument with the right-hand side of the comparison
+            fixer.replaceText(matcherArg, sourceCode.getText(comparison.right))];
           },
 
           messageId: 'useToBeComparison',
           data: {
             preferredMatcher
           },
-          node: matcher.node.property
+          node: matcher
         });
       }
 

package/lib/rules/prefer-equality-matcher.js

@@ -9,22 +9,6 @@ var _utils = require("@typescript-eslint/utils");
 
 var _utils2 = require("./utils");
 
-const isBooleanLiteral = node => node.type === _utils.AST_NODE_TYPES.Literal && typeof node.value === 'boolean';
-
-/**
- * Checks if the given `ParsedExpectMatcher` is a call to one of the equality matchers,
- * with a boolean literal as the sole argument.
- *
- * @example javascript
- * toBe(true);
- * toEqual(false);
- *
- * @param {ParsedExpectMatcher} matcher
- *
- * @return {matcher is ParsedBooleanEqualityMatcher}
- */
-const isBooleanEqualityMatcher = matcher => (0, _utils2.isParsedEqualityMatcherCall)(matcher) && isBooleanLiteral((0, _utils2.followTypeAssertionChain)(matcher.arguments[0]));
-
 var _default = (0, _utils2.createRule)({
   name: __filename,
   meta: {
@@ -47,35 +31,44 @@ var _default = (0, _utils2.createRule)({
   create(context) {
     return {
       CallExpression(node) {
-        if (!(0, _utils2.isExpectCall)(node)) {
+        const jestFnCall = (0, _utils2.parseJestFnCall)(node, context);
+
+        if ((jestFnCall === null || jestFnCall === void 0 ? void 0 : jestFnCall.type) !== 'expect' || jestFnCall.args.length === 0) {
           return;
         }
 
         const {
-          expect: {
-            arguments: [comparison],
-            range: [, expectCallEnd]
-          },
-          matcher,
-          modifier
-        } = (0, _utils2.parseExpectCall)(node);
-
-        if (!matcher || (comparison === null || comparison === void 0 ? void 0 : comparison.type) !== _utils.AST_NODE_TYPES.BinaryExpression || comparison.operator !== '===' && comparison.operator !== '!==' || !isBooleanEqualityMatcher(matcher)) {
+          parent: expect
+        } = jestFnCall.head.node;
+
+        if ((expect === null || expect === void 0 ? void 0 : expect.type) !== _utils.AST_NODE_TYPES.CallExpression) {
+          return;
+        }
+
+        const {
+          arguments: [comparison],
+          range: [, expectCallEnd]
+        } = expect;
+        const {
+          matcher
+        } = jestFnCall;
+        const matcherArg = (0, _utils2.getFirstMatcherArg)(jestFnCall);
+
+        if ((comparison === null || comparison === void 0 ? void 0 : comparison.type) !== _utils.AST_NODE_TYPES.BinaryExpression || comparison.operator !== '===' && comparison.operator !== '!==' || !_utils2.EqualityMatcher.hasOwnProperty((0, _utils2.getAccessorValue)(matcher)) || !(0, _utils2.isBooleanLiteral)(matcherArg)) {
           return;
         }
 
-        const matcherValue = (0, _utils2.followTypeAssertionChain)(matcher.arguments[0]).value;
-        const negation = modifier !== null && modifier !== void 0 && modifier.negation ? {
-          node: modifier.negation
-        } : (modifier === null || modifier === void 0 ? void 0 : modifier.name) === _utils2.ModifierName.not ? modifier : null; // we need to negate the expectation if the current expected
+        const matcherValue = matcherArg.value;
+        const [modifier] = jestFnCall.modifiers;
+        const hasNot = jestFnCall.modifiers.some(nod => (0, _utils2.getAccessorValue)(nod) === 'not'); // we need to negate the expectation if the current expected
         // value is itself negated by the "not" modifier
 
-        const addNotModifier = (comparison.operator === '!==' ? !matcherValue : matcherValue) === !!negation;
+        const addNotModifier = (comparison.operator === '!==' ? !matcherValue : matcherValue) === hasNot;
 
         const buildFixer = equalityMatcher => fixer => {
           const sourceCode = context.getSourceCode(); // preserve the existing modifier if it's not a negation
 
-          let modifierText = modifier && (modifier === null || modifier === void 0 ? void 0 : modifier.node) !== (negation === null || negation === void 0 ? void 0 : negation.node) ? `.${modifier.name}` : '';
+          let modifierText = modifier && (0, _utils2.getAccessorValue)(modifier) !== 'not' ? `.${(0, _utils2.getAccessorValue)(modifier)}` : '';
 
           if (addNotModifier) {
             modifierText += `.${_utils2.ModifierName.not}`;
@@ -83,8 +76,8 @@ var _default = (0, _utils2.createRule)({
 
           return [// replace the comparison argument with the left-hand side of the comparison
           fixer.replaceText(comparison, sourceCode.getText(comparison.left)), // replace the current matcher & modifier with the preferred matcher
-          fixer.replaceTextRange([expectCallEnd, matcher.node.range[1]], `${modifierText}.${equalityMatcher}`), // replace the matcher argument with the right-hand side of the comparison
-          fixer.replaceText(matcher.arguments[0], sourceCode.getText(comparison.right))];
+          fixer.replaceTextRange([expectCallEnd, matcher.parent.range[1]], `${modifierText}.${equalityMatcher}`), // replace the matcher argument with the right-hand side of the comparison
+          fixer.replaceText(matcherArg, sourceCode.getText(comparison.right))];
         };
 
         context.report({
@@ -96,7 +89,7 @@ var _default = (0, _utils2.createRule)({
             },
             fix: buildFixer(equalityMatcher)
           })),
-          node: matcher.node.property
+          node: matcher
         });
       }
 

package/lib/rules/prefer-expect-assertions.js

@@ -116,12 +116,14 @@ var _default = (0, _utils2.createRule)({
       'ForOfStatement:exit': exitForLoop,
 
       CallExpression(node) {
-        if ((0, _utils2.isTypeOfJestFnCall)(node, context, ['test'])) {
+        const jestFnCall = (0, _utils2.parseJestFnCall)(node, context);
+
+        if ((jestFnCall === null || jestFnCall === void 0 ? void 0 : jestFnCall.type) === 'test') {
           inTestCaseCall = true;
           return;
         }
 
-        if ((0, _utils2.isExpectCall)(node) && inTestCaseCall) {
+        if ((jestFnCall === null || jestFnCall === void 0 ? void 0 : jestFnCall.type) === 'expect' && inTestCaseCall) {
           if (inForLoop) {
             hasExpectInLoop = true;
           }

package/lib/rules/prefer-expect-resolves.js

@@ -27,15 +27,29 @@ var _default = (0, _utils2.createRule)({
   defaultOptions: [],
   create: context => ({
     CallExpression(node) {
-      const [awaitNode] = node.arguments;
+      const jestFnCall = (0, _utils2.parseJestFnCall)(node, context);
 
-      if ((0, _utils2.isExpectCall)(node) && (awaitNode === null || awaitNode === void 0 ? void 0 : awaitNode.type) === _utils.AST_NODE_TYPES.AwaitExpression) {
+      if ((jestFnCall === null || jestFnCall === void 0 ? void 0 : jestFnCall.type) !== 'expect') {
+        return;
+      }
+
+      const {
+        parent
+      } = jestFnCall.head.node;
+
+      if ((parent === null || parent === void 0 ? void 0 : parent.type) !== _utils.AST_NODE_TYPES.CallExpression) {
+        return;
+      }
+
+      const [awaitNode] = parent.arguments;
+
+      if ((awaitNode === null || awaitNode === void 0 ? void 0 : awaitNode.type) === _utils.AST_NODE_TYPES.AwaitExpression) {
         context.report({
-          node: node.arguments[0],
+          node: awaitNode,
           messageId: 'expectResolves',
 
           fix(fixer) {
-            return [fixer.insertTextBefore(node, 'await '), fixer.removeRange([awaitNode.range[0], awaitNode.argument.range[0]]), fixer.insertTextAfter(node, '.resolves')];
+            return [fixer.insertTextBefore(parent, 'await '), fixer.removeRange([awaitNode.range[0], awaitNode.argument.range[0]]), fixer.insertTextAfter(parent, '.resolves')];
           }
 
         });

package/lib/rules/prefer-snapshot-hint.js

@@ -8,28 +8,25 @@ exports.default = void 0;
 var _utils = require("./utils");
 
 const snapshotMatchers = ['toMatchSnapshot', 'toThrowErrorMatchingSnapshot'];
+const snapshotMatcherNames = snapshotMatchers;
 
-const isSnapshotMatcher = matcher => {
-  return snapshotMatchers.includes(matcher.name);
-};
-
-const isSnapshotMatcherWithoutHint = matcher => {
-  if (!matcher.arguments || matcher.arguments.length === 0) {
+const isSnapshotMatcherWithoutHint = expectFnCall => {
+  if (expectFnCall.args.length === 0) {
     return true;
   } // this matcher only supports one argument which is the hint
 
 
-  if (matcher.name !== 'toMatchSnapshot') {
-    return matcher.arguments.length !== 1;
+  if (!(0, _utils.isSupportedAccessor)(expectFnCall.matcher, 'toMatchSnapshot')) {
+    return expectFnCall.args.length !== 1;
   } // if we're being passed two arguments,
   // the second one should be the hint
 
 
-  if (matcher.arguments.length === 2) {
+  if (expectFnCall.args.length === 2) {
     return false;
   }
 
-  const [arg] = matcher.arguments; // the first argument to `toMatchSnapshot` can be _either_ a snapshot hint or
+  const [arg] = expectFnCall.args; // the first argument to `toMatchSnapshot` can be _either_ a snapshot hint or
   // an object with asymmetric matchers, so we can't just assume that the first
   // argument is a hint when it's by itself.
 
@@ -67,7 +64,7 @@ var _default = (0, _utils.createRule)({
         if (isSnapshotMatcherWithoutHint(snapshotMatcher)) {
           context.report({
             messageId: 'missingHint',
-            node: snapshotMatcher.node.property
+            node: snapshotMatcher.matcher
           });
         }
       }
@@ -115,24 +112,24 @@ var _default = (0, _utils.createRule)({
       },
 
       CallExpression(node) {
-        if ((0, _utils.isTypeOfJestFnCall)(node, context, ['describe', 'test'])) {
-          depths.push(expressionDepth);
-          expressionDepth = 0;
-        }
+        const jestFnCall = (0, _utils.parseJestFnCall)(node, context);
+
+        if ((jestFnCall === null || jestFnCall === void 0 ? void 0 : jestFnCall.type) !== 'expect') {
+          if ((jestFnCall === null || jestFnCall === void 0 ? void 0 : jestFnCall.type) === 'describe' || (jestFnCall === null || jestFnCall === void 0 ? void 0 : jestFnCall.type) === 'test') {
+            depths.push(expressionDepth);
+            expressionDepth = 0;
+          }
 
-        if (!(0, _utils.isExpectCall)(node)) {
           return;
         }
 
-        const {
-          matcher
-        } = (0, _utils.parseExpectCall)(node);
+        const matcherName = (0, _utils.getAccessorValue)(jestFnCall.matcher);
 
-        if (!matcher || !isSnapshotMatcher(matcher)) {
+        if (!snapshotMatcherNames.includes(matcherName)) {
           return;
         }
 
-        snapshotMatchers.push(matcher);
+        snapshotMatchers.push(jestFnCall);
       }
 
     };