eslint-plugin-react-hooks 4.0.8 → 4.1.2

package/cjs/eslint-plugin-react-hooks.development.js

@@ -13,11 +13,81 @@ if (process.env.NODE_ENV !== "production") {
   (function() {
 'use strict';
 
+function _unsupportedIterableToArray(o, minLen) {
+  if (!o) return;
+  if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+  var n = Object.prototype.toString.call(o).slice(8, -1);
+  if (n === "Object" && o.constructor) n = o.constructor.name;
+  if (n === "Map" || n === "Set") return Array.from(o);
+  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+}
+
+function _arrayLikeToArray(arr, len) {
+  if (len == null || len > arr.length) len = arr.length;
+
+  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
+
+  return arr2;
+}
+
+function _createForOfIteratorHelper(o, allowArrayLike) {
+  var it;
+
+  if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) {
+    if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {
+      if (it) o = it;
+      var i = 0;
+
+      var F = function () {};
+
+      return {
+        s: F,
+        n: function () {
+          if (i >= o.length) return {
+            done: true
+          };
+          return {
+            done: false,
+            value: o[i++]
+          };
+        },
+        e: function (e) {
+          throw e;
+        },
+        f: F
+      };
+    }
+
+    throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+  }
+
+  var normalCompletion = true,
+      didErr = false,
+      err;
+  return {
+    s: function () {
+      it = o[Symbol.iterator]();
+    },
+    n: function () {
+      var step = it.next();
+      normalCompletion = step.done;
+      return step;
+    },
+    e: function (e) {
+      didErr = true;
+      err = e;
+    },
+    f: function () {
+      try {
+        if (!normalCompletion && it.return != null) it.return();
+      } finally {
+        if (didErr) throw err;
+      }
+    }
+  };
+}
+
 /* eslint-disable no-for-of-loops/no-for-of-loops */
-/**
- * Catch all identifiers that begin with "use" followed by an uppercase Latin
- * character to exclude identifiers like "user".
- */
 
 function isHookName(s) {
   return /^use[A-Z0-9].*$/.test(s);
@@ -165,28 +235,19 @@ var RulesOfHooks = {
           if (pathList.has(segment.id)) {
             var pathArray = [].concat(pathList);
             var cyclicSegments = pathArray.slice(pathArray.indexOf(segment.id) + 1);
-            var _iteratorNormalCompletion = true;
-            var _didIteratorError = false;
-            var _iteratorError = undefined;
+
+            var _iterator = _createForOfIteratorHelper(cyclicSegments),
+                _step;
 
             try {
-              for (var _iterator = cyclicSegments[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+              for (_iterator.s(); !(_step = _iterator.n()).done;) {
                 var cyclicSegment = _step.value;
                 cyclic.add(cyclicSegment);
               }
             } catch (err) {
-              _didIteratorError = true;
-              _iteratorError = err;
+              _iterator.e(err);
             } finally {
-              try {
-                if (!_iteratorNormalCompletion && _iterator.return != null) {
-                  _iterator.return();
-                }
-              } finally {
-                if (_didIteratorError) {
-                  throw _iteratorError;
-                }
-              }
+              _iterator.f();
             }
 
             return 0;
@@ -205,28 +266,19 @@ var RulesOfHooks = {
             paths = 1;
           } else {
             paths = 0;
-            var _iteratorNormalCompletion2 = true;
-            var _didIteratorError2 = false;
-            var _iteratorError2 = undefined;
+
+            var _iterator2 = _createForOfIteratorHelper(segment.prevSegments),
+                _step2;
 
             try {
-              for (var _iterator2 = segment.prevSegments[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
+              for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
                 var prevSegment = _step2.value;
                 paths += countPathsFromStart(prevSegment, pathList);
               }
             } catch (err) {
-              _didIteratorError2 = true;
-              _iteratorError2 = err;
+              _iterator2.e(err);
             } finally {
-              try {
-                if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
-                  _iterator2.return();
-                }
-              } finally {
-                if (_didIteratorError2) {
-                  throw _iteratorError2;
-                }
-              }
+              _iterator2.f();
             }
           } // If our segment is reachable then there should be at least one path
           // to it from the start of our code path.
@@ -272,28 +324,19 @@ var RulesOfHooks = {
           if (pathList.has(segment.id)) {
             var pathArray = Array.from(pathList);
             var cyclicSegments = pathArray.slice(pathArray.indexOf(segment.id) + 1);
-            var _iteratorNormalCompletion3 = true;
-            var _didIteratorError3 = false;
-            var _iteratorError3 = undefined;
+
+            var _iterator3 = _createForOfIteratorHelper(cyclicSegments),
+                _step3;
 
             try {
-              for (var _iterator3 = cyclicSegments[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
+              for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
                 var cyclicSegment = _step3.value;
                 cyclic.add(cyclicSegment);
               }
             } catch (err) {
-              _didIteratorError3 = true;
-              _iteratorError3 = err;
+              _iterator3.e(err);
             } finally {
-              try {
-                if (!_iteratorNormalCompletion3 && _iterator3.return != null) {
-                  _iterator3.return();
-                }
-              } finally {
-                if (_didIteratorError3) {
-                  throw _iteratorError3;
-                }
-              }
+              _iterator3.f();
             }
 
             return 0;
@@ -312,28 +355,19 @@ var RulesOfHooks = {
             paths = 1;
           } else {
             paths = 0;
-            var _iteratorNormalCompletion4 = true;
-            var _didIteratorError4 = false;
-            var _iteratorError4 = undefined;
+
+            var _iterator4 = _createForOfIteratorHelper(segment.nextSegments),
+                _step4;
 
             try {
-              for (var _iterator4 = segment.nextSegments[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) {
+              for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
                 var nextSegment = _step4.value;
                 paths += countPathsToEnd(nextSegment, pathList);
               }
             } catch (err) {
-              _didIteratorError4 = true;
-              _iteratorError4 = err;
+              _iterator4.e(err);
             } finally {
-              try {
-                if (!_iteratorNormalCompletion4 && _iterator4.return != null) {
-                  _iterator4.return();
-                }
-              } finally {
-                if (_didIteratorError4) {
-                  throw _iteratorError4;
-                }
-              }
+              _iterator4.f();
             }
           }
 
@@ -384,12 +418,12 @@ var RulesOfHooks = {
             length = 1;
           } else {
             length = Infinity;
-            var _iteratorNormalCompletion5 = true;
-            var _didIteratorError5 = false;
-            var _iteratorError5 = undefined;
+
+            var _iterator5 = _createForOfIteratorHelper(segment.prevSegments),
+                _step5;
 
             try {
-              for (var _iterator5 = segment.prevSegments[Symbol.iterator](), _step5; !(_iteratorNormalCompletion5 = (_step5 = _iterator5.next()).done); _iteratorNormalCompletion5 = true) {
+              for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
                 var prevSegment = _step5.value;
                 var prevLength = shortestPathLengthToStart(prevSegment);
 
@@ -398,18 +432,9 @@ var RulesOfHooks = {
                 }
               }
             } catch (err) {
-              _didIteratorError5 = true;
-              _iteratorError5 = err;
+              _iterator5.e(err);
             } finally {
-              try {
-                if (!_iteratorNormalCompletion5 && _iterator5.return != null) {
-                  _iterator5.return();
-                }
-              } finally {
-                if (_didIteratorError5) {
-                  throw _iteratorError5;
-                }
-              }
+              _iterator5.f();
             }
 
             length += 1;
@@ -440,12 +465,12 @@ var RulesOfHooks = {
         // after calling `visitSegment()`.
 
         var shortestFinalPathLength = Infinity;
-        var _iteratorNormalCompletion6 = true;
-        var _didIteratorError6 = false;
-        var _iteratorError6 = undefined;
+
+        var _iterator6 = _createForOfIteratorHelper(codePath.finalSegments),
+            _step6;
 
         try {
-          for (var _iterator6 = codePath.finalSegments[Symbol.iterator](), _step6; !(_iteratorNormalCompletion6 = (_step6 = _iterator6.next()).done); _iteratorNormalCompletion6 = true) {
+          for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
             var finalSegment = _step6.value;
 
             if (!finalSegment.reachable) {
@@ -461,26 +486,16 @@ var RulesOfHooks = {
           // if not.
 
         } catch (err) {
-          _didIteratorError6 = true;
-          _iteratorError6 = err;
+          _iterator6.e(err);
         } finally {
-          try {
-            if (!_iteratorNormalCompletion6 && _iterator6.return != null) {
-              _iterator6.return();
-            }
-          } finally {
-            if (_didIteratorError6) {
-              throw _iteratorError6;
-            }
-          }
+          _iterator6.f();
         }
 
-        var _iteratorNormalCompletion7 = true;
-        var _didIteratorError7 = false;
-        var _iteratorError7 = undefined;
+        var _iterator7 = _createForOfIteratorHelper(reactHooksMap),
+            _step7;
 
         try {
-          for (var _iterator7 = reactHooksMap[Symbol.iterator](), _step7; !(_iteratorNormalCompletion7 = (_step7 = _iterator7.next()).done); _iteratorNormalCompletion7 = true) {
+          for (_iterator7.s(); !(_step7 = _iterator7.n()).done;) {
             var _step7$value = _step7.value,
                 segment = _step7$value[0],
                 reactHooks = _step7$value[1];
@@ -536,12 +551,12 @@ var RulesOfHooks = {
             var pathsFromStartToEnd = countPathsFromStart(segment) * countPathsToEnd(segment); // Is this hook a part of a cyclic segment?
 
             var cycled = cyclic.has(segment.id);
-            var _iteratorNormalCompletion8 = true;
-            var _didIteratorError8 = false;
-            var _iteratorError8 = undefined;
+
+            var _iterator8 = _createForOfIteratorHelper(reactHooks),
+                _step8;
 
             try {
-              for (var _iterator8 = reactHooks[Symbol.iterator](), _step8; !(_iteratorNormalCompletion8 = (_step8 = _iterator8.next()).done); _iteratorNormalCompletion8 = true) {
+              for (_iterator8.s(); !(_step8 = _iterator8.n()).done;) {
                 var hook = _step8.value;
 
                 // Report an error if a hook may be called more then once.
@@ -610,33 +625,15 @@ var RulesOfHooks = {
                 }
               }
             } catch (err) {
-              _didIteratorError8 = true;
-              _iteratorError8 = err;
+              _iterator8.e(err);
             } finally {
-              try {
-                if (!_iteratorNormalCompletion8 && _iterator8.return != null) {
-                  _iterator8.return();
-                }
-              } finally {
-                if (_didIteratorError8) {
-                  throw _iteratorError8;
-                }
-              }
+              _iterator8.f();
             }
           }
         } catch (err) {
-          _didIteratorError7 = true;
-          _iteratorError7 = err;
+          _iterator7.e(err);
         } finally {
-          try {
-            if (!_iteratorNormalCompletion7 && _iterator7.return != null) {
-              _iterator7.return();
-            }
-          } finally {
-            if (_didIteratorError7) {
-              throw _iteratorError7;
-            }
-          }
+          _iterator7.f();
         }
       },
       // Missed opportunity...We could visit all `Identifier`s instead of all
@@ -718,7 +715,6 @@ function last(array) {
 }
 
 /* eslint-disable no-for-of-loops/no-for-of-loops */
-
 var ExhaustiveDeps = {
   meta: {
     type: 'suggestion',
@@ -784,139 +780,6 @@ var ExhaustiveDeps = {
         return result;
       };
     }
-
-    return {
-      CallExpression: visitCallExpression
-    };
-
-    function visitCallExpression(node) {
-      var callbackIndex = getReactiveHookCallbackIndex(node.callee, options);
-
-      if (callbackIndex === -1) {
-        // Not a React Hook call that needs deps.
-        return;
-      }
-
-      var callback = node.arguments[callbackIndex];
-      var reactiveHook = node.callee;
-      var reactiveHookName = getNodeWithoutReactNamespace(reactiveHook).name;
-      var declaredDependenciesNode = node.arguments[callbackIndex + 1];
-      var isEffect = /Effect($|[^a-z])/g.test(reactiveHookName); // Check the declared dependencies for this reactive hook. If there is no
-      // second argument then the reactive callback will re-run on every render.
-      // So no need to check for dependency inclusion.
-
-      if (!declaredDependenciesNode && !isEffect) {
-        // These are only used for optimization.
-        if (reactiveHookName === 'useMemo' || reactiveHookName === 'useCallback') {
-          // TODO: Can this have a suggestion?
-          reportProblem({
-            node: reactiveHook,
-            message: "React Hook " + reactiveHookName + " does nothing when called with " + "only one argument. Did you forget to pass an array of " + "dependencies?"
-          });
-        }
-
-        return;
-      }
-
-      switch (callback.type) {
-        case 'FunctionExpression':
-        case 'ArrowFunctionExpression':
-          visitFunctionWithDependencies(callback, declaredDependenciesNode, reactiveHook, reactiveHookName, isEffect);
-          return;
-        // Handled
-
-        case 'Identifier':
-          if (!declaredDependenciesNode) {
-            // No deps, no problems.
-            return; // Handled
-          } // The function passed as a callback is not written inline.
-          // But perhaps it's in the dependencies array?
-
-
-          if (declaredDependenciesNode.elements && declaredDependenciesNode.elements.some(function (el) {
-            return el && el.type === 'Identifier' && el.name === callback.name;
-          })) {
-            // If it's already in the list of deps, we don't care because
-            // this is valid regardless.
-            return; // Handled
-          } // We'll do our best effort to find it, complain otherwise.
-
-
-          var variable = context.getScope().set.get(callback.name);
-
-          if (variable == null || variable.defs == null) {
-            // If it's not in scope, we don't care.
-            return; // Handled
-          } // The function passed as a callback is not written inline.
-          // But it's defined somewhere in the render scope.
-          // We'll do our best effort to find and check it, complain otherwise.
-
-
-          var def = variable.defs[0];
-
-          if (!def || !def.node) {
-            break; // Unhandled
-          }
-
-          if (def.type !== 'Variable' && def.type !== 'FunctionName') {
-            // Parameter or an unusual pattern. Bail out.
-            break; // Unhandled
-          }
-
-          switch (def.node.type) {
-            case 'FunctionDeclaration':
-              // useEffect(() => { ... }, []);
-              visitFunctionWithDependencies(def.node, declaredDependenciesNode, reactiveHook, reactiveHookName, isEffect);
-              return;
-            // Handled
-
-            case 'VariableDeclarator':
-              var init = def.node.init;
-
-              if (!init) {
-                break; // Unhandled
-              }
-
-              switch (init.type) {
-                // const effectBody = () => {...};
-                // useEffect(effectBody, []);
-                case 'ArrowFunctionExpression':
-                case 'FunctionExpression':
-                  // We can inspect this function as if it were inline.
-                  visitFunctionWithDependencies(init, declaredDependenciesNode, reactiveHook, reactiveHookName, isEffect);
-                  return;
-                // Handled
-              }
-
-              break;
-            // Unhandled
-          }
-
-          break;
-        // Unhandled
-
-        default:
-          // useEffect(generateEffectBody(), []);
-          reportProblem({
-            node: reactiveHook,
-            message: "React Hook " + reactiveHookName + " received a function whose dependencies " + "are unknown. Pass an inline function instead."
-          });
-          return;
-        // Handled
-      } // Something unusual. Fall back to suggesting to add the body itself as a dep.
-
-
-      reportProblem({
-        node: reactiveHook,
-        message: "React Hook " + reactiveHookName + " has a missing dependency: '" + callback.name + "'. " + "Either include it or remove the dependency array.",
-        suggest: [{
-          desc: "Update the dependencies array to be: [" + callback.name + "]",
-          fix: function (fixer) {
-            return fixer.replaceText(declaredDependenciesNode, "[" + callback.name + "]");
-          }
-        }]
-      });
-    }
     /**
      * Visitor for both function expressions and arrow function expressions.
      */
@@ -926,7 +789,7 @@ var ExhaustiveDeps = {
       if (isEffect && node.async) {
         reportProblem({
           node: node,
-          message: "Effect callbacks are synchronous to prevent race conditions. " + "Put the async function inside:\n\n" + 'useEffect(() => {\n' + '  async function fetchData() {\n' + '    // You can await here\n' + '    const response = await MyAPI.getData(someId);\n' + '    // ...\n' + '  }\n' + '  fetchData();\n' + "}, [someId]); // Or [] if effect doesn't need props or state\n\n" + 'Learn more about data fetching with Hooks: https://fb.me/react-hooks-data-fetching'
+          message: "Effect callbacks are synchronous to prevent race conditions. " + "Put the async function inside:\n\n" + 'useEffect(() => {\n' + '  async function fetchData() {\n' + '    // You can await here\n' + '    const response = await MyAPI.getData(someId);\n' + '    // ...\n' + '  }\n' + '  fetchData();\n' + "}, [someId]); // Or [] if effect doesn't need props or state\n\n" + 'Learn more about data fetching with Hooks: https://reactjs.org/link/hooks-data-fetching'
         });
       } // Get the current scope.
 
@@ -1072,6 +935,14 @@ var ExhaustiveDeps = {
               return false;
             }
           }
+        } else if (name === 'useTransition') {
+          if (id.type === 'ArrayPattern' && Array.isArray(resolved.identifiers)) {
+            // Is first tuple value the same reference we're checking?
+            if (id.elements[0] === resolved.identifiers[0]) {
+              // Setter is stable.
+              return true;
+            }
+          }
         } // By default assume it's dynamic.
 
 
@@ -1170,12 +1041,11 @@ var ExhaustiveDeps = {
       gatherDependenciesRecursively(scope);
 
       function gatherDependenciesRecursively(currentScope) {
-        var _iteratorNormalCompletion = true;
-        var _didIteratorError = false;
-        var _iteratorError = undefined;
+        var _iterator = _createForOfIteratorHelper(currentScope.references),
+            _step;
 
         try {
-          for (var _iterator = currentScope.references[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+          for (_iterator.s(); !(_step = _iterator.n()).done;) {
             var reference = _step.value;
 
             // If this reference is not resolved or it is not declared in a pure
@@ -1204,7 +1074,7 @@ var ExhaustiveDeps = {
               });
             }
 
-            if (dependencyNode.parent.type === 'TSTypeQuery') {
+            if (dependencyNode.parent.type === 'TSTypeQuery' || dependencyNode.parent.type === 'TSTypeReference') {
               continue;
             }
 
@@ -1238,42 +1108,23 @@ var ExhaustiveDeps = {
             }
           }
         } catch (err) {
-          _didIteratorError = true;
-          _iteratorError = err;
+          _iterator.e(err);
         } finally {
-          try {
-            if (!_iteratorNormalCompletion && _iterator.return != null) {
-              _iterator.return();
-            }
-          } finally {
-            if (_didIteratorError) {
-              throw _iteratorError;
-            }
-          }
+          _iterator.f();
         }
 
-        var _iteratorNormalCompletion2 = true;
-        var _didIteratorError2 = false;
-        var _iteratorError2 = undefined;
+        var _iterator2 = _createForOfIteratorHelper(currentScope.childScopes),
+            _step2;
 
         try {
-          for (var _iterator2 = currentScope.childScopes[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
+          for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
             var childScope = _step2.value;
             gatherDependenciesRecursively(childScope);
           }
         } catch (err) {
-          _didIteratorError2 = true;
-          _iteratorError2 = err;
+          _iterator2.e(err);
         } finally {
-          try {
-            if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
-              _iterator2.return();
-            }
-          } finally {
-            if (_didIteratorError2) {
-              throw _iteratorError2;
-            }
-          }
+          _iterator2.f();
         }
       } // Warn about accessing .current in cleanup effects.
 
@@ -1473,8 +1324,8 @@ var ExhaustiveDeps = {
 
           var maybeID = declaredDependencyNode;
 
-          while (maybeID.type === 'MemberExpression' || maybeID.type === 'OptionalMemberExpression') {
-            maybeID = maybeID.object;
+          while (maybeID.type === 'MemberExpression' || maybeID.type === 'OptionalMemberExpression' || maybeID.type === 'ChainExpression') {
+            maybeID = maybeID.object || maybeID.expression.object;
           }
 
           var isDeclaredInComponent = !componentScope.through.some(function (ref) {
@@ -1508,38 +1359,44 @@ var ExhaustiveDeps = {
       var problemCount = duplicateDependencies.size + missingDependencies.size + unnecessaryDependencies.size;
 
       if (problemCount === 0) {
-        // If nothing else to report, check if some callbacks
-        // are bare and would invalidate on every render.
-        var bareFunctions = scanForDeclaredBareFunctions({
+        // If nothing else to report, check if some dependencies would
+        // invalidate on every render.
+        var constructions = scanForConstructions({
           declaredDependencies: declaredDependencies,
           declaredDependenciesNode: declaredDependenciesNode,
           componentScope: componentScope,
           scope: scope
         });
-        bareFunctions.forEach(function (_ref4) {
-          var fn = _ref4.fn,
-              suggestUseCallback = _ref4.suggestUseCallback;
-          var message = "The '" + fn.name.name + "' function makes the dependencies of " + (reactiveHookName + " Hook (at line " + declaredDependenciesNode.loc.start.line + ") ") + "change on every render.";
-
-          if (suggestUseCallback) {
-            message += " To fix this, " + ("wrap the '" + fn.name.name + "' definition into its own useCallback() Hook.");
-          } else {
-            message += " Move it inside the " + reactiveHookName + " callback. " + ("Alternatively, wrap the '" + fn.name.name + "' definition into its own useCallback() Hook.");
-          }
-
-          var suggest; // Only handle the simple case: arrow functions.
+        constructions.forEach(function (_ref4) {
+          var construction = _ref4.construction,
+              isUsedOutsideOfHook = _ref4.isUsedOutsideOfHook,
+              depType = _ref4.depType;
+          var wrapperHook = depType === 'function' ? 'useCallback' : 'useMemo';
+          var constructionType = depType === 'function' ? 'definition' : 'initialization';
+          var defaultAdvice = "wrap the " + constructionType + " of '" + construction.name.name + "' in its own " + wrapperHook + "() Hook.";
+          var advice = isUsedOutsideOfHook ? "To fix this, " + defaultAdvice : "Move it inside the " + reactiveHookName + " callback. Alternatively, " + defaultAdvice;
+          var causation = depType === 'conditional' || depType === 'logical expression' ? 'could make' : 'makes';
+          var message = "The '" + construction.name.name + "' " + depType + " " + causation + " the dependencies of " + (reactiveHookName + " Hook (at line " + declaredDependenciesNode.loc.start.line + ") ") + ("change on every render. " + advice);
+          var suggest; // Only handle the simple case of variable assignments.
           // Wrapping function declarations can mess up hoisting.
 
-          if (suggestUseCallback && fn.type === 'Variable') {
+          if (isUsedOutsideOfHook && construction.type === 'Variable' && // Objects may be mutated ater construction, which would make this
+          // fix unsafe. Functions _probably_ won't be mutated, so we'll
+          // allow this fix for them.
+          depType === 'function') {
             suggest = [{
-              desc: "Wrap the '" + fn.name.name + "' definition into its own useCallback() Hook.",
+              desc: "Wrap the " + constructionType + " of '" + construction.name.name + "' in its own " + wrapperHook + "() Hook.",
               fix: function (fixer) {
+                var _ref5 = wrapperHook === 'useMemo' ? ["useMemo(() => { return ", '; })'] : ['useCallback(', ')'],
+                    before = _ref5[0],
+                    after = _ref5[1];
+
                 return [// TODO: also add an import?
-                fixer.insertTextBefore(fn.node.init, 'useCallback('), // TODO: ideally we'd gather deps here but it would require
+                fixer.insertTextBefore(construction.node.init, before), // TODO: ideally we'd gather deps here but it would require
                 // restructuring the rule code. This will cause a new lint
                 // error to appear immediately for useCallback. Note we're
                 // not adding [] because would that changes semantics.
-                fixer.insertTextAfter(fn.node.init, ')')];
+                fixer.insertTextAfter(construction.node.init, after)];
               }
             }];
           } // TODO: What if the function needs to change on every render anyway?
@@ -1548,7 +1405,7 @@ var ExhaustiveDeps = {
 
           reportProblem({
             // TODO: Why not report this at the dependency site?
-            node: fn.node,
+            node: construction.node,
             message: message,
             suggest: suggest
           });
@@ -1844,15 +1701,148 @@ var ExhaustiveDeps = {
         }]
       });
     }
+
+    function visitCallExpression(node) {
+      var callbackIndex = getReactiveHookCallbackIndex(node.callee, options);
+
+      if (callbackIndex === -1) {
+        // Not a React Hook call that needs deps.
+        return;
+      }
+
+      var callback = node.arguments[callbackIndex];
+      var reactiveHook = node.callee;
+      var reactiveHookName = getNodeWithoutReactNamespace(reactiveHook).name;
+      var declaredDependenciesNode = node.arguments[callbackIndex + 1];
+      var isEffect = /Effect($|[^a-z])/g.test(reactiveHookName); // Check the declared dependencies for this reactive hook. If there is no
+      // second argument then the reactive callback will re-run on every render.
+      // So no need to check for dependency inclusion.
+
+      if (!declaredDependenciesNode && !isEffect) {
+        // These are only used for optimization.
+        if (reactiveHookName === 'useMemo' || reactiveHookName === 'useCallback') {
+          // TODO: Can this have a suggestion?
+          reportProblem({
+            node: reactiveHook,
+            message: "React Hook " + reactiveHookName + " does nothing when called with " + "only one argument. Did you forget to pass an array of " + "dependencies?"
+          });
+        }
+
+        return;
+      }
+
+      switch (callback.type) {
+        case 'FunctionExpression':
+        case 'ArrowFunctionExpression':
+          visitFunctionWithDependencies(callback, declaredDependenciesNode, reactiveHook, reactiveHookName, isEffect);
+          return;
+        // Handled
+
+        case 'Identifier':
+          if (!declaredDependenciesNode) {
+            // No deps, no problems.
+            return; // Handled
+          } // The function passed as a callback is not written inline.
+          // But perhaps it's in the dependencies array?
+
+
+          if (declaredDependenciesNode.elements && declaredDependenciesNode.elements.some(function (el) {
+            return el && el.type === 'Identifier' && el.name === callback.name;
+          })) {
+            // If it's already in the list of deps, we don't care because
+            // this is valid regardless.
+            return; // Handled
+          } // We'll do our best effort to find it, complain otherwise.
+
+
+          var variable = context.getScope().set.get(callback.name);
+
+          if (variable == null || variable.defs == null) {
+            // If it's not in scope, we don't care.
+            return; // Handled
+          } // The function passed as a callback is not written inline.
+          // But it's defined somewhere in the render scope.
+          // We'll do our best effort to find and check it, complain otherwise.
+
+
+          var def = variable.defs[0];
+
+          if (!def || !def.node) {
+            break; // Unhandled
+          }
+
+          if (def.type !== 'Variable' && def.type !== 'FunctionName') {
+            // Parameter or an unusual pattern. Bail out.
+            break; // Unhandled
+          }
+
+          switch (def.node.type) {
+            case 'FunctionDeclaration':
+              // useEffect(() => { ... }, []);
+              visitFunctionWithDependencies(def.node, declaredDependenciesNode, reactiveHook, reactiveHookName, isEffect);
+              return;
+            // Handled
+
+            case 'VariableDeclarator':
+              var init = def.node.init;
+
+              if (!init) {
+                break; // Unhandled
+              }
+
+              switch (init.type) {
+                // const effectBody = () => {...};
+                // useEffect(effectBody, []);
+                case 'ArrowFunctionExpression':
+                case 'FunctionExpression':
+                  // We can inspect this function as if it were inline.
+                  visitFunctionWithDependencies(init, declaredDependenciesNode, reactiveHook, reactiveHookName, isEffect);
+                  return;
+                // Handled
+              }
+
+              break;
+            // Unhandled
+          }
+
+          break;
+        // Unhandled
+
+        default:
+          // useEffect(generateEffectBody(), []);
+          reportProblem({
+            node: reactiveHook,
+            message: "React Hook " + reactiveHookName + " received a function whose dependencies " + "are unknown. Pass an inline function instead."
+          });
+          return;
+        // Handled
+      } // Something unusual. Fall back to suggesting to add the body itself as a dep.
+
+
+      reportProblem({
+        node: reactiveHook,
+        message: "React Hook " + reactiveHookName + " has a missing dependency: '" + callback.name + "'. " + "Either include it or remove the dependency array.",
+        suggest: [{
+          desc: "Update the dependencies array to be: [" + callback.name + "]",
+          fix: function (fixer) {
+            return fixer.replaceText(declaredDependenciesNode, "[" + callback.name + "]");
+          }
+        }]
+      });
+    }
+
+    return {
+      CallExpression: visitCallExpression
+    };
   }
 }; // The meat of the logic.
 
-function collectRecommendations(_ref5) {
-  var dependencies = _ref5.dependencies,
-      declaredDependencies = _ref5.declaredDependencies,
-      stableDependencies = _ref5.stableDependencies,
-      externalDependencies = _ref5.externalDependencies,
-      isEffect = _ref5.isEffect;
+function collectRecommendations(_ref6) {
+  var dependencies = _ref6.dependencies,
+      declaredDependencies = _ref6.declaredDependencies,
+      stableDependencies = _ref6.stableDependencies,
+      externalDependencies = _ref6.externalDependencies,
+      isEffect = _ref6.isEffect;
   // Our primary data structure.
   // It is a logical representation of property chains:
   // `props` -> `props.foo` -> `props.foo.bar` -> `props.foo.bar.baz`
@@ -1888,8 +1878,8 @@ function collectRecommendations(_ref5) {
   }); // Mark all satisfied nodes.
   // Imagine checkmarks next to each declared dependency.
 
-  declaredDependencies.forEach(function (_ref6) {
-    var key = _ref6.key;
+  declaredDependencies.forEach(function (_ref7) {
+    var key = _ref7.key;
     var node = getOrCreateNodeByPath(depTree, key);
     node.isSatisfiedRecursively = true;
   });
@@ -1901,12 +1891,12 @@ function collectRecommendations(_ref5) {
   function getOrCreateNodeByPath(rootNode, path) {
     var keys = path.split('.');
     var node = rootNode;
-    var _iteratorNormalCompletion3 = true;
-    var _didIteratorError3 = false;
-    var _iteratorError3 = undefined;
+
+    var _iterator3 = _createForOfIteratorHelper(keys),
+        _step3;
 
     try {
-      for (var _iterator3 = keys[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
+      for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
         var key = _step3.value;
         var child = node.children.get(key);
 
@@ -1918,18 +1908,9 @@ function collectRecommendations(_ref5) {
         node = child;
       }
     } catch (err) {
-      _didIteratorError3 = true;
-      _iteratorError3 = err;
+      _iterator3.e(err);
     } finally {
-      try {
-        if (!_iteratorNormalCompletion3 && _iterator3.return != null) {
-          _iterator3.return();
-        }
-      } finally {
-        if (_didIteratorError3) {
-          throw _iteratorError3;
-        }
-      }
+      _iterator3.f();
     }
 
     return node;
@@ -1938,12 +1919,12 @@ function collectRecommendations(_ref5) {
   function markAllParentsByPath(rootNode, path, fn) {
     var keys = path.split('.');
     var node = rootNode;
-    var _iteratorNormalCompletion4 = true;
-    var _didIteratorError4 = false;
-    var _iteratorError4 = undefined;
+
+    var _iterator4 = _createForOfIteratorHelper(keys),
+        _step4;
 
     try {
-      for (var _iterator4 = keys[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) {
+      for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
         var key = _step4.value;
         var child = node.children.get(key);
 
@@ -1955,18 +1936,9 @@ function collectRecommendations(_ref5) {
         node = child;
       }
     } catch (err) {
-      _didIteratorError4 = true;
-      _iteratorError4 = err;
+      _iterator4.e(err);
     } finally {
-      try {
-        if (!_iteratorNormalCompletion4 && _iterator4.return != null) {
-          _iterator4.return();
-        }
-      } finally {
-        if (_didIteratorError4) {
-          throw _iteratorError4;
-        }
-      }
+      _iterator4.f();
     }
   } // Now we can learn which dependencies are missing or necessary.
 
@@ -2011,8 +1983,8 @@ function collectRecommendations(_ref5) {
   var suggestedDependencies = [];
   var unnecessaryDependencies = new Set();
   var duplicateDependencies = new Set();
-  declaredDependencies.forEach(function (_ref7) {
-    var key = _ref7.key;
+  declaredDependencies.forEach(function (_ref8) {
+    var key = _ref8.key;
 
     // Does this declared dep satisfy a real need?
     if (satisfyingDependencies.has(key)) {
@@ -2048,48 +2020,127 @@ function collectRecommendations(_ref5) {
     duplicateDependencies: duplicateDependencies,
     missingDependencies: missingDependencies
   };
-} // Finds functions declared as dependencies
+} // If the node will result in constructing a referentially unique value, return
+// its human readable type name, else return null.
+
+
+function getConstructionExpressionType(node) {
+  switch (node.type) {
+    case 'ObjectExpression':
+      return 'object';
+
+    case 'ArrayExpression':
+      return 'array';
+
+    case 'ArrowFunctionExpression':
+    case 'FunctionExpression':
+      return 'function';
+
+    case 'ClassExpression':
+      return 'class';
+
+    case 'ConditionalExpression':
+      if (getConstructionExpressionType(node.consequent) != null || getConstructionExpressionType(node.alternate) != null) {
+        return 'conditional';
+      }
+
+      return null;
+
+    case 'LogicalExpression':
+      if (getConstructionExpressionType(node.left) != null || getConstructionExpressionType(node.right) != null) {
+        return 'logical expression';
+      }
+
+      return null;
+
+    case 'JSXFragment':
+      return 'JSX fragment';
+
+    case 'JSXElement':
+      return 'JSX element';
+
+    case 'AssignmentExpression':
+      if (getConstructionExpressionType(node.right) != null) {
+        return 'assignment expression';
+      }
+
+      return null;
+
+    case 'NewExpression':
+      return 'object construction';
+
+    case 'Literal':
+      if (node.value instanceof RegExp) {
+        return 'regular expression';
+      }
+
+      return null;
+
+    case 'TypeCastExpression':
+      return getConstructionExpressionType(node.expression);
+
+    case 'TSAsExpression':
+      return getConstructionExpressionType(node.expression);
+  }
+
+  return null;
+} // Finds variables declared as dependencies
 // that would invalidate on every render.
 
 
-function scanForDeclaredBareFunctions(_ref8) {
-  var declaredDependencies = _ref8.declaredDependencies,
-      declaredDependenciesNode = _ref8.declaredDependenciesNode,
-      componentScope = _ref8.componentScope,
-      scope = _ref8.scope;
-  var bareFunctions = declaredDependencies.map(function (_ref9) {
-    var key = _ref9.key;
-    var fnRef = componentScope.set.get(key);
+function scanForConstructions(_ref9) {
+  var declaredDependencies = _ref9.declaredDependencies,
+      declaredDependenciesNode = _ref9.declaredDependenciesNode,
+      componentScope = _ref9.componentScope,
+      scope = _ref9.scope;
+  var constructions = declaredDependencies.map(function (_ref10) {
+    var key = _ref10.key;
+    var ref = componentScope.variables.find(function (v) {
+      return v.name === key;
+    });
 
-    if (fnRef == null) {
+    if (ref == null) {
       return null;
     }
 
-    var fnNode = fnRef.defs[0];
+    var node = ref.defs[0];
 
-    if (fnNode == null) {
+    if (node == null) {
       return null;
     } // const handleChange = function () {}
     // const handleChange = () => {}
+    // const foo = {}
+    // const foo = []
+    // etc.
+
 
+    if (node.type === 'Variable' && node.node.type === 'VariableDeclarator' && node.node.id.type === 'Identifier' && // Ensure this is not destructed assignment
+    node.node.init != null) {
+      var constantExpressionType = getConstructionExpressionType(node.node.init);
 
-    if (fnNode.type === 'Variable' && fnNode.node.type === 'VariableDeclarator' && fnNode.node.init != null && (fnNode.node.init.type === 'ArrowFunctionExpression' || fnNode.node.init.type === 'FunctionExpression')) {
-      return fnRef;
+      if (constantExpressionType != null) {
+        return [ref, constantExpressionType];
+      }
     } // function handleChange() {}
 
 
-    if (fnNode.type === 'FunctionName' && fnNode.node.type === 'FunctionDeclaration') {
-      return fnRef;
+    if (node.type === 'FunctionName' && node.node.type === 'FunctionDeclaration') {
+      return [ref, 'function'];
+    } // class Foo {}
+
+
+    if (node.type === 'ClassName' && node.node.type === 'ClassDeclaration') {
+      return [ref, 'class'];
     }
 
     return null;
   }).filter(Boolean);
 
-  function isUsedOutsideOfHook(fnRef) {
+  function isUsedOutsideOfHook(ref) {
     var foundWriteExpr = false;
 
-    for (var i = 0; i < fnRef.references.length; i++) {
-      var reference = fnRef.references[i];
+    for (var i = 0; i < ref.references.length; i++) {
+      var reference = ref.references[i];
 
       if (reference.writeExpr) {
         if (foundWriteExpr) {
@@ -2120,10 +2171,13 @@ function scanForDeclaredBareFunctions(_ref8) {
     return false;
   }
 
-  return bareFunctions.map(function (fnRef) {
+  return constructions.map(function (_ref11) {
+    var ref = _ref11[0],
+        depType = _ref11[1];
     return {
-      fn: fnRef.defs[0],
-      suggestUseCallback: isUsedOutsideOfHook(fnRef)
+      construction: ref.defs[0],
+      depType: depType,
+      isUsedOutsideOfHook: isUsedOutsideOfHook(ref)
     };
   });
 }
@@ -2146,6 +2200,28 @@ function getDependency(node) {
     return node;
   }
 }
+/**
+ * Mark a node as either optional or required.
+ * Note: If the node argument is an OptionalMemberExpression, it doesn't necessarily mean it is optional.
+ * It just means there is an optional member somewhere inside.
+ * This particular node might still represent a required member, so check .optional field.
+ */
+
+
+function markNode(node, optionalChains, result) {
+  if (optionalChains) {
+    if (node.optional) {
+      // We only want to consider it optional if *all* usages were optional.
+      if (!optionalChains.has(result)) {
+        // Mark as (maybe) optional. If there's a required usage, this will be overridden.
+        optionalChains.set(result, true);
+      }
+    } else {
+      // Mark as required.
+      optionalChains.set(result, false);
+    }
+  }
+}
 /**
  * Assuming () means the passed node.
  * (foo) -> 'foo'
@@ -2156,7 +2232,7 @@ function getDependency(node) {
 
 
 function analyzePropertyChain(node, optionalChains) {
-  if (node.type === 'Identifier') {
+  if (node.type === 'Identifier' || node.type === 'JSXIdentifier') {
     var result = node.name;
 
     if (optionalChains) {
@@ -2171,11 +2247,7 @@ function analyzePropertyChain(node, optionalChains) {
 
     var _result = object + "." + property;
 
-    if (optionalChains) {
-      // Mark as required.
-      optionalChains.set(_result, false);
-    }
-
+    markNode(node, optionalChains, _result);
     return _result;
   } else if (node.type === 'OptionalMemberExpression' && !node.computed) {
     var _object = analyzePropertyChain(node.object, optionalChains);
@@ -2184,23 +2256,19 @@ function analyzePropertyChain(node, optionalChains) {
 
     var _result2 = _object + "." + _property;
 
-    if (optionalChains) {
-      // Note: OptionalMemberExpression doesn't necessarily mean this node is optional.
-      // It just means there is an optional member somewhere inside.
-      // This particular node might still represent a required member, so check .optional field.
-      if (node.optional) {
-        // We only want to consider it optional if *all* usages were optional.
-        if (!optionalChains.has(_result2)) {
-          // Mark as (maybe) optional. If there's a required usage, this will be overridden.
-          optionalChains.set(_result2, true);
-        }
-      } else {
-        // Mark as required.
-        optionalChains.set(_result2, false);
-      }
-    }
-
+    markNode(node, optionalChains, _result2);
     return _result2;
+  } else if (node.type === 'ChainExpression' && !node.computed) {
+    var expression = node.expression;
+
+    var _object2 = analyzePropertyChain(expression.object, optionalChains);
+
+    var _property2 = analyzePropertyChain(expression.property, null);
+
+    var _result3 = _object2 + "." + _property2;
+
+    markNode(expression, optionalChains, _result3);
+    return _result3;
   } else {
     throw new Error("Unsupported node type: " + node.type);
   }
@@ -2337,7 +2405,7 @@ function isNodeLike(val) {
 }
 
 function isSameIdentifier(a, b) {
-  return a.type === 'Identifier' && a.name === b.name && a.range[0] === b.range[0] && a.range[1] === b.range[1];
+  return (a.type === 'Identifier' || a.type === 'JSXIdentifier') && a.type === b.type && a.name === b.name && a.range[0] === b.range[0] && a.range[1] === b.range[1];
 }
 
 function isAncestorNodeOf(a, b) {