eslint-plugin-react-hooks 7.1.0-canary-fd524fe0-20251121 → 7.1.0-canary-7dc903cd-20251203

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

@@ -18347,7 +18347,7 @@ function getRuleForCategoryImpl(category) {
                 severity: ErrorSeverity.Error,
                 name: 'memo-dependencies',
                 description: 'Validates that useMemo() and useCallback() specify comprehensive dependencies without extraneous values. See [`useMemo()` docs](https://react.dev/reference/react/useMemo) for more information.',
-                preset: LintRulePreset.RecommendedLatest,
+                preset: LintRulePreset.Off,
             };
         }
         case ErrorCategory.IncompatibleLibrary: {
@@ -18863,6 +18863,10 @@ function isSubPath(subpath, path) {
         subpath.every((item, ix) => item.property === path[ix].property &&
             item.optional === path[ix].optional));
 }
+function isSubPathIgnoringOptionals(subpath, path) {
+    return (subpath.length <= path.length &&
+        subpath.every((item, ix) => item.property === path[ix].property));
+}
 function getPlaceScope(id, place) {
     const scope = place.identifier.scope;
     if (scope !== null && isScopeActive(scope, id)) {
@@ -19066,6 +19070,9 @@ function isUseInsertionEffectHookType(id) {
     return (id.type.kind === 'Function' &&
         id.type.shapeId === 'BuiltInUseInsertionEffectHook');
 }
+function isUseEffectEventType(id) {
+    return (id.type.kind === 'Function' && id.type.shapeId === 'BuiltInUseEffectEvent');
+}
 function isUseContextHookType(id) {
     return (id.type.kind === 'Function' && id.type.shapeId === 'BuiltInUseContextHook');
 }
@@ -32198,7 +32205,7 @@ const EnvironmentConfigSchema = v4.z.object({
     enableResetCacheOnSourceFileChanges: v4.z.nullable(v4.z.boolean()).default(null),
     enablePreserveExistingMemoizationGuarantees: v4.z.boolean().default(true),
     validatePreserveExistingMemoizationGuarantees: v4.z.boolean().default(true),
-    validateExhaustiveMemoizationDependencies: v4.z.boolean().default(false),
+    validateExhaustiveMemoizationDependencies: v4.z.boolean().default(true),
     enablePreserveExistingManualUseMemo: v4.z.boolean().default(false),
     enableForest: v4.z.boolean().default(false),
     enableUseTypeAnnotations: v4.z.boolean().default(false),
@@ -34482,6 +34489,19 @@ function evaluateInstruction(constants, instr) {
             constantPropagationImpl(value.loweredFunc.func, constants);
             return null;
         }
+        case 'StartMemoize': {
+            if (value.deps != null) {
+                for (const dep of value.deps) {
+                    if (dep.root.kind === 'NamedLocal') {
+                        const placeValue = read(constants, dep.root.value);
+                        if (placeValue != null && placeValue.kind === 'Primitive') {
+                            dep.root.constant = true;
+                        }
+                    }
+                }
+            }
+            return null;
+        }
         default: {
             return null;
         }
@@ -44599,6 +44619,7 @@ function collectMaybeMemoDependencies(value, maybeDeps, optional) {
                     identifierName: value.binding.name,
                 },
                 path: [],
+                loc: value.loc,
             };
         }
         case 'PropertyLoad': {
@@ -44607,6 +44628,7 @@ function collectMaybeMemoDependencies(value, maybeDeps, optional) {
                 return {
                     root: object.root,
                     path: [...object.path, { property: value.property, optional }],
+                    loc: value.loc,
                 };
             }
             break;
@@ -44623,8 +44645,10 @@ function collectMaybeMemoDependencies(value, maybeDeps, optional) {
                     root: {
                         kind: 'NamedLocal',
                         value: Object.assign({}, value.place),
+                        constant: false,
                     },
                     path: [],
+                    loc: value.place.loc,
                 };
             }
             break;
@@ -50186,6 +50210,7 @@ function validateInferredDep(dep, temporaries, declsWithinMemoBlock, validDepsIn
         normalizedDep = {
             root: maybeNormalizedRoot.root,
             path: [...maybeNormalizedRoot.path, ...dep.path],
+            loc: maybeNormalizedRoot.loc,
         };
     }
     else {
@@ -50211,8 +50236,10 @@ function validateInferredDep(dep, temporaries, declsWithinMemoBlock, validDepsIn
                     effect: Effect.Read,
                     reactive: false,
                 },
+                constant: false,
             },
             path: [...dep.path],
+            loc: GeneratedSource,
         };
     }
     for (const decl of declsWithinMemoBlock) {
@@ -50298,8 +50325,10 @@ class Visitor extends ReactiveFunctionVisitor {
                                 root: {
                                     kind: 'NamedLocal',
                                     value: storeTarget,
+                                    constant: false,
                                 },
                                 path: [],
+                                loc: storeTarget.loc,
                             });
                         }
                     }
@@ -50326,8 +50355,10 @@ class Visitor extends ReactiveFunctionVisitor {
                 root: {
                     kind: 'NamedLocal',
                     value: Object.assign({}, lvalue),
+                    constant: false,
                 },
                 path: [],
+                loc: lvalue.loc,
             });
         }
     }
@@ -51172,7 +51203,16 @@ function validateNoSetStateInEffects(fn, env) {
                     const callee = instr.value.kind === 'MethodCall'
                         ? instr.value.receiver
                         : instr.value.callee;
-                    if (isUseEffectHookType(callee.identifier) ||
+                    if (isUseEffectEventType(callee.identifier)) {
+                        const arg = instr.value.args[0];
+                        if (arg !== undefined && arg.kind === 'Identifier') {
+                            const setState = setStateFunctions.get(arg.identifier.id);
+                            if (setState !== undefined) {
+                                setStateFunctions.set(instr.lvalue.identifier.id, setState);
+                            }
+                        }
+                    }
+                    else if (isUseEffectHookType(callee.identifier) ||
                         isUseLayoutEffectHookType(callee.identifier) ||
                         isUseInsertionEffectHookType(callee.identifier)) {
                         const arg = instr.value.args[0];
@@ -53447,7 +53487,7 @@ function validateExhaustiveDependencies(fn) {
         locals.clear();
     }
     function onFinishMemoize(value, dependencies, locals) {
-        var _b, _c, _d;
+        var _b, _c, _d, _e, _f, _g, _h, _j;
         CompilerError.simpleInvariant(startMemo != null && startMemo.manualMemoId === value.manualMemoId, {
             reason: 'Found FinishMemoize without corresponding StartMemoize',
             loc: value.loc,
@@ -53526,80 +53566,123 @@ function validateExhaustiveDependencies(fn) {
                 reason: 'Unexpected function dependency',
                 loc: value.loc,
             });
-            const isRequiredDependency = reactive.has(inferredDependency.identifier.id) ||
-                !isStableType(inferredDependency.identifier);
             let hasMatchingManualDependency = false;
             for (const manualDependency of manualDependencies) {
                 if (manualDependency.root.kind === 'NamedLocal' &&
                     manualDependency.root.value.identifier.id ===
                         inferredDependency.identifier.id &&
                     (areEqualPaths(manualDependency.path, inferredDependency.path) ||
-                        isSubPath(manualDependency.path, inferredDependency.path))) {
+                        isSubPathIgnoringOptionals(manualDependency.path, inferredDependency.path))) {
                     hasMatchingManualDependency = true;
                     matched.add(manualDependency);
-                    if (!isRequiredDependency) {
-                        extra.push(manualDependency);
-                    }
                 }
             }
-            if (isRequiredDependency && !hasMatchingManualDependency) {
-                missing.push(inferredDependency);
+            if (hasMatchingManualDependency ||
+                isOptionalDependency(inferredDependency, reactive)) {
+                continue;
             }
+            missing.push(inferredDependency);
         }
         for (const dep of (_c = startMemo.deps) !== null && _c !== void 0 ? _c : []) {
             if (matched.has(dep)) {
                 continue;
             }
+            if (dep.root.kind === 'NamedLocal' && dep.root.constant) {
+                CompilerError.simpleInvariant(!dep.root.value.reactive &&
+                    isPrimitiveType(dep.root.value.identifier), {
+                    reason: 'Expected constant-folded dependency to be non-reactive',
+                    loc: dep.root.value.loc,
+                });
+                continue;
+            }
             extra.push(dep);
         }
         if (missing.length !== 0 || extra.length !== 0) {
-            let suggestions = null;
+            let suggestion = null;
             if (startMemo.depsLoc != null && typeof startMemo.depsLoc !== 'symbol') {
-                suggestions = [
-                    {
-                        description: 'Update dependencies',
-                        range: [startMemo.depsLoc.start.index, startMemo.depsLoc.end.index],
-                        op: CompilerSuggestionOperation.Replace,
-                        text: `[${inferred.map(printInferredDependency).join(', ')}]`,
-                    },
-                ];
+                suggestion = {
+                    description: 'Update dependencies',
+                    range: [startMemo.depsLoc.start.index, startMemo.depsLoc.end.index],
+                    op: CompilerSuggestionOperation.Replace,
+                    text: `[${inferred
+                        .filter(dep => dep.kind === 'Local' && !isOptionalDependency(dep, reactive))
+                        .map(printInferredDependency)
+                        .join(', ')}]`,
+                };
             }
-            if (missing.length !== 0) {
-                const diagnostic = CompilerDiagnostic.create({
-                    category: ErrorCategory.MemoDependencies,
-                    reason: 'Found non-exhaustive dependencies',
-                    description: 'Missing dependencies can cause a value not to update when those inputs change, ' +
-                        'resulting in stale UI',
-                    suggestions,
+            const diagnostic = CompilerDiagnostic.create({
+                category: ErrorCategory.MemoDependencies,
+                reason: 'Found missing/extra memoization dependencies',
+                description: [
+                    missing.length !== 0
+                        ? 'Missing dependencies can cause a value to update less often than it should, ' +
+                            'resulting in stale UI'
+                        : null,
+                    extra.length !== 0
+                        ? 'Extra dependencies can cause a value to update more often than it should, ' +
+                            'resulting in performance problems such as excessive renders or effects firing too often'
+                        : null,
+                ]
+                    .filter(Boolean)
+                    .join('. '),
+                suggestions: suggestion != null ? [suggestion] : null,
+            });
+            for (const dep of missing) {
+                let reactiveStableValueHint = '';
+                if (isStableType(dep.identifier)) {
+                    reactiveStableValueHint =
+                        '. Refs, setState functions, and other "stable" values generally do not need to be added ' +
+                            'as dependencies, but this variable may change over time to point to different values';
+                }
+                diagnostic.withDetails({
+                    kind: 'error',
+                    message: `Missing dependency \`${printInferredDependency(dep)}\`${reactiveStableValueHint}`,
+                    loc: dep.loc,
                 });
-                for (const dep of missing) {
-                    let reactiveStableValueHint = '';
-                    if (isStableType(dep.identifier)) {
-                        reactiveStableValueHint =
-                            '. Refs, setState functions, and other "stable" values generally do not need to be added as dependencies, but this variable may change over time to point to different values';
-                    }
+            }
+            for (const dep of extra) {
+                if (dep.root.kind === 'Global') {
                     diagnostic.withDetails({
                         kind: 'error',
-                        message: `Missing dependency \`${printInferredDependency(dep)}\`${reactiveStableValueHint}`,
-                        loc: dep.loc,
+                        message: `Unnecessary dependency \`${printManualMemoDependency(dep)}\`. ` +
+                            'Values declared outside of a component/hook should not be listed as ' +
+                            'dependencies as the component will not re-render if they change',
+                        loc: (_e = (_d = dep.loc) !== null && _d !== void 0 ? _d : startMemo.depsLoc) !== null && _e !== void 0 ? _e : value.loc,
+                    });
+                    error.pushDiagnostic(diagnostic);
+                }
+                else {
+                    const root = dep.root.value;
+                    const matchingInferred = inferred.find((inferredDep) => {
+                        return (inferredDep.kind === 'Local' &&
+                            inferredDep.identifier.id === root.identifier.id &&
+                            isSubPathIgnoringOptionals(inferredDep.path, dep.path));
                     });
+                    if (matchingInferred != null &&
+                        !isOptionalDependency(matchingInferred, reactive)) {
+                        diagnostic.withDetails({
+                            kind: 'error',
+                            message: `Overly precise dependency \`${printManualMemoDependency(dep)}\`, ` +
+                                `use \`${printInferredDependency(matchingInferred)}\` instead`,
+                            loc: (_g = (_f = dep.loc) !== null && _f !== void 0 ? _f : startMemo.depsLoc) !== null && _g !== void 0 ? _g : value.loc,
+                        });
+                    }
+                    else {
+                        diagnostic.withDetails({
+                            kind: 'error',
+                            message: `Unnecessary dependency \`${printManualMemoDependency(dep)}\``,
+                            loc: (_j = (_h = dep.loc) !== null && _h !== void 0 ? _h : startMemo.depsLoc) !== null && _j !== void 0 ? _j : value.loc,
+                        });
+                    }
                 }
-                error.pushDiagnostic(diagnostic);
             }
-            else if (extra.length !== 0) {
-                const diagnostic = CompilerDiagnostic.create({
-                    category: ErrorCategory.MemoDependencies,
-                    reason: 'Found unnecessary memoization dependencies',
-                    description: 'Unnecessary dependencies can cause a value to update more often than necessary, ' +
-                        'which can cause effects to run more than expected',
-                });
+            if (suggestion != null) {
                 diagnostic.withDetails({
-                    kind: 'error',
-                    message: `Unnecessary dependencies ${extra.map(dep => `\`${printManualMemoDependency(dep)}\``).join(', ')}`,
-                    loc: (_d = startMemo.depsLoc) !== null && _d !== void 0 ? _d : value.loc,
+                    kind: 'hint',
+                    message: `Inferred dependencies: \`${suggestion.text}\``,
                 });
-                error.pushDiagnostic(diagnostic);
             }
+            error.pushDiagnostic(diagnostic);
         }
         dependencies.clear();
         locals.clear();
@@ -53990,6 +54073,11 @@ function findOptionalPlaces(fn) {
     }
     return optionals;
 }
+function isOptionalDependency(inferredDependency, reactive) {
+    return (!reactive.has(inferredDependency.identifier.id) &&
+        (isStableType(inferredDependency.identifier) ||
+            isPrimitiveType(inferredDependency.identifier)));
+}
 
 function run(func, config, fnType, mode, programContext, logger, filename, code) {
     var _a, _b;
@@ -54116,8 +54204,10 @@ function runWithEnvironment(func, env) {
     }
     inferReactivePlaces(hir);
     log({ kind: 'hir', name: 'InferReactivePlaces', value: hir });
-    if (env.config.validateExhaustiveMemoizationDependencies) {
-        validateExhaustiveDependencies(hir).unwrap();
+    if (env.enableValidations) {
+        if (env.config.validateExhaustiveMemoizationDependencies) {
+            validateExhaustiveDependencies(hir).unwrap();
+        }
     }
     rewriteInstructionKindsBasedOnReassignment(hir);
     log({
@@ -54380,7 +54470,7 @@ function findProgramSuppressions(programComments, ruleNames, flowSuppressions) {
     let disableNextLinePattern = null;
     let disablePattern = null;
     let enablePattern = null;
-    if (ruleNames.length !== 0) {
+    if (ruleNames != null && ruleNames.length !== 0) {
         const rulePattern = `(${ruleNames.join('|')})`;
         disableNextLinePattern = new RegExp(`eslint-disable-next-line ${rulePattern}`);
         disablePattern = new RegExp(`eslint-disable ${rulePattern}`);
@@ -54717,7 +54807,10 @@ function compileProgram(program, pass) {
         handleError(restrictedImportsErr, pass, null);
         return null;
     }
-    const suppressions = findProgramSuppressions(pass.comments, (_a = pass.opts.eslintSuppressionRules) !== null && _a !== void 0 ? _a : DEFAULT_ESLINT_SUPPRESSIONS, pass.opts.flowSuppressions);
+    const suppressions = findProgramSuppressions(pass.comments, pass.opts.environment.validateExhaustiveMemoizationDependencies &&
+        pass.opts.environment.validateHooksUsage
+        ? null
+        : ((_a = pass.opts.eslintSuppressionRules) !== null && _a !== void 0 ? _a : DEFAULT_ESLINT_SUPPRESSIONS), pass.opts.flowSuppressions);
     const programContext = new ProgramContext({
         program: program,
         opts: pass.opts,

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

@@ -18338,7 +18338,7 @@ function getRuleForCategoryImpl(category) {
                 severity: ErrorSeverity.Error,
                 name: 'memo-dependencies',
                 description: 'Validates that useMemo() and useCallback() specify comprehensive dependencies without extraneous values. See [`useMemo()` docs](https://react.dev/reference/react/useMemo) for more information.',
-                preset: LintRulePreset.RecommendedLatest,
+                preset: LintRulePreset.Off,
             };
         }
         case ErrorCategory.IncompatibleLibrary: {
@@ -18854,6 +18854,10 @@ function isSubPath(subpath, path) {
         subpath.every((item, ix) => item.property === path[ix].property &&
             item.optional === path[ix].optional));
 }
+function isSubPathIgnoringOptionals(subpath, path) {
+    return (subpath.length <= path.length &&
+        subpath.every((item, ix) => item.property === path[ix].property));
+}
 function getPlaceScope(id, place) {
     const scope = place.identifier.scope;
     if (scope !== null && isScopeActive(scope, id)) {
@@ -19057,6 +19061,9 @@ function isUseInsertionEffectHookType(id) {
     return (id.type.kind === 'Function' &&
         id.type.shapeId === 'BuiltInUseInsertionEffectHook');
 }
+function isUseEffectEventType(id) {
+    return (id.type.kind === 'Function' && id.type.shapeId === 'BuiltInUseEffectEvent');
+}
 function isUseContextHookType(id) {
     return (id.type.kind === 'Function' && id.type.shapeId === 'BuiltInUseContextHook');
 }
@@ -32025,7 +32032,7 @@ const EnvironmentConfigSchema = v4.z.object({
     enableResetCacheOnSourceFileChanges: v4.z.nullable(v4.z.boolean()).default(null),
     enablePreserveExistingMemoizationGuarantees: v4.z.boolean().default(true),
     validatePreserveExistingMemoizationGuarantees: v4.z.boolean().default(true),
-    validateExhaustiveMemoizationDependencies: v4.z.boolean().default(false),
+    validateExhaustiveMemoizationDependencies: v4.z.boolean().default(true),
     enablePreserveExistingManualUseMemo: v4.z.boolean().default(false),
     enableForest: v4.z.boolean().default(false),
     enableUseTypeAnnotations: v4.z.boolean().default(false),
@@ -34309,6 +34316,19 @@ function evaluateInstruction(constants, instr) {
             constantPropagationImpl(value.loweredFunc.func, constants);
             return null;
         }
+        case 'StartMemoize': {
+            if (value.deps != null) {
+                for (const dep of value.deps) {
+                    if (dep.root.kind === 'NamedLocal') {
+                        const placeValue = read(constants, dep.root.value);
+                        if (placeValue != null && placeValue.kind === 'Primitive') {
+                            dep.root.constant = true;
+                        }
+                    }
+                }
+            }
+            return null;
+        }
         default: {
             return null;
         }
@@ -44426,6 +44446,7 @@ function collectMaybeMemoDependencies(value, maybeDeps, optional) {
                     identifierName: value.binding.name,
                 },
                 path: [],
+                loc: value.loc,
             };
         }
         case 'PropertyLoad': {
@@ -44434,6 +44455,7 @@ function collectMaybeMemoDependencies(value, maybeDeps, optional) {
                 return {
                     root: object.root,
                     path: [...object.path, { property: value.property, optional }],
+                    loc: value.loc,
                 };
             }
             break;
@@ -44450,8 +44472,10 @@ function collectMaybeMemoDependencies(value, maybeDeps, optional) {
                     root: {
                         kind: 'NamedLocal',
                         value: Object.assign({}, value.place),
+                        constant: false,
                     },
                     path: [],
+                    loc: value.place.loc,
                 };
             }
             break;
@@ -50013,6 +50037,7 @@ function validateInferredDep(dep, temporaries, declsWithinMemoBlock, validDepsIn
         normalizedDep = {
             root: maybeNormalizedRoot.root,
             path: [...maybeNormalizedRoot.path, ...dep.path],
+            loc: maybeNormalizedRoot.loc,
         };
     }
     else {
@@ -50038,8 +50063,10 @@ function validateInferredDep(dep, temporaries, declsWithinMemoBlock, validDepsIn
                     effect: Effect.Read,
                     reactive: false,
                 },
+                constant: false,
             },
             path: [...dep.path],
+            loc: GeneratedSource,
         };
     }
     for (const decl of declsWithinMemoBlock) {
@@ -50125,8 +50152,10 @@ class Visitor extends ReactiveFunctionVisitor {
                                 root: {
                                     kind: 'NamedLocal',
                                     value: storeTarget,
+                                    constant: false,
                                 },
                                 path: [],
+                                loc: storeTarget.loc,
                             });
                         }
                     }
@@ -50153,8 +50182,10 @@ class Visitor extends ReactiveFunctionVisitor {
                 root: {
                     kind: 'NamedLocal',
                     value: Object.assign({}, lvalue),
+                    constant: false,
                 },
                 path: [],
+                loc: lvalue.loc,
             });
         }
     }
@@ -50999,7 +51030,16 @@ function validateNoSetStateInEffects(fn, env) {
                     const callee = instr.value.kind === 'MethodCall'
                         ? instr.value.receiver
                         : instr.value.callee;
-                    if (isUseEffectHookType(callee.identifier) ||
+                    if (isUseEffectEventType(callee.identifier)) {
+                        const arg = instr.value.args[0];
+                        if (arg !== undefined && arg.kind === 'Identifier') {
+                            const setState = setStateFunctions.get(arg.identifier.id);
+                            if (setState !== undefined) {
+                                setStateFunctions.set(instr.lvalue.identifier.id, setState);
+                            }
+                        }
+                    }
+                    else if (isUseEffectHookType(callee.identifier) ||
                         isUseLayoutEffectHookType(callee.identifier) ||
                         isUseInsertionEffectHookType(callee.identifier)) {
                         const arg = instr.value.args[0];
@@ -53274,7 +53314,7 @@ function validateExhaustiveDependencies(fn) {
         locals.clear();
     }
     function onFinishMemoize(value, dependencies, locals) {
-        var _b, _c, _d;
+        var _b, _c, _d, _e, _f, _g, _h, _j;
         CompilerError.simpleInvariant(startMemo != null && startMemo.manualMemoId === value.manualMemoId, {
             reason: 'Found FinishMemoize without corresponding StartMemoize',
             loc: value.loc,
@@ -53353,80 +53393,123 @@ function validateExhaustiveDependencies(fn) {
                 reason: 'Unexpected function dependency',
                 loc: value.loc,
             });
-            const isRequiredDependency = reactive.has(inferredDependency.identifier.id) ||
-                !isStableType(inferredDependency.identifier);
             let hasMatchingManualDependency = false;
             for (const manualDependency of manualDependencies) {
                 if (manualDependency.root.kind === 'NamedLocal' &&
                     manualDependency.root.value.identifier.id ===
                         inferredDependency.identifier.id &&
                     (areEqualPaths(manualDependency.path, inferredDependency.path) ||
-                        isSubPath(manualDependency.path, inferredDependency.path))) {
+                        isSubPathIgnoringOptionals(manualDependency.path, inferredDependency.path))) {
                     hasMatchingManualDependency = true;
                     matched.add(manualDependency);
-                    if (!isRequiredDependency) {
-                        extra.push(manualDependency);
-                    }
                 }
             }
-            if (isRequiredDependency && !hasMatchingManualDependency) {
-                missing.push(inferredDependency);
+            if (hasMatchingManualDependency ||
+                isOptionalDependency(inferredDependency, reactive)) {
+                continue;
             }
+            missing.push(inferredDependency);
         }
         for (const dep of (_c = startMemo.deps) !== null && _c !== void 0 ? _c : []) {
             if (matched.has(dep)) {
                 continue;
             }
+            if (dep.root.kind === 'NamedLocal' && dep.root.constant) {
+                CompilerError.simpleInvariant(!dep.root.value.reactive &&
+                    isPrimitiveType(dep.root.value.identifier), {
+                    reason: 'Expected constant-folded dependency to be non-reactive',
+                    loc: dep.root.value.loc,
+                });
+                continue;
+            }
             extra.push(dep);
         }
         if (missing.length !== 0 || extra.length !== 0) {
-            let suggestions = null;
+            let suggestion = null;
             if (startMemo.depsLoc != null && typeof startMemo.depsLoc !== 'symbol') {
-                suggestions = [
-                    {
-                        description: 'Update dependencies',
-                        range: [startMemo.depsLoc.start.index, startMemo.depsLoc.end.index],
-                        op: CompilerSuggestionOperation.Replace,
-                        text: `[${inferred.map(printInferredDependency).join(', ')}]`,
-                    },
-                ];
+                suggestion = {
+                    description: 'Update dependencies',
+                    range: [startMemo.depsLoc.start.index, startMemo.depsLoc.end.index],
+                    op: CompilerSuggestionOperation.Replace,
+                    text: `[${inferred
+                        .filter(dep => dep.kind === 'Local' && !isOptionalDependency(dep, reactive))
+                        .map(printInferredDependency)
+                        .join(', ')}]`,
+                };
             }
-            if (missing.length !== 0) {
-                const diagnostic = CompilerDiagnostic.create({
-                    category: ErrorCategory.MemoDependencies,
-                    reason: 'Found non-exhaustive dependencies',
-                    description: 'Missing dependencies can cause a value not to update when those inputs change, ' +
-                        'resulting in stale UI',
-                    suggestions,
+            const diagnostic = CompilerDiagnostic.create({
+                category: ErrorCategory.MemoDependencies,
+                reason: 'Found missing/extra memoization dependencies',
+                description: [
+                    missing.length !== 0
+                        ? 'Missing dependencies can cause a value to update less often than it should, ' +
+                            'resulting in stale UI'
+                        : null,
+                    extra.length !== 0
+                        ? 'Extra dependencies can cause a value to update more often than it should, ' +
+                            'resulting in performance problems such as excessive renders or effects firing too often'
+                        : null,
+                ]
+                    .filter(Boolean)
+                    .join('. '),
+                suggestions: suggestion != null ? [suggestion] : null,
+            });
+            for (const dep of missing) {
+                let reactiveStableValueHint = '';
+                if (isStableType(dep.identifier)) {
+                    reactiveStableValueHint =
+                        '. Refs, setState functions, and other "stable" values generally do not need to be added ' +
+                            'as dependencies, but this variable may change over time to point to different values';
+                }
+                diagnostic.withDetails({
+                    kind: 'error',
+                    message: `Missing dependency \`${printInferredDependency(dep)}\`${reactiveStableValueHint}`,
+                    loc: dep.loc,
                 });
-                for (const dep of missing) {
-                    let reactiveStableValueHint = '';
-                    if (isStableType(dep.identifier)) {
-                        reactiveStableValueHint =
-                            '. Refs, setState functions, and other "stable" values generally do not need to be added as dependencies, but this variable may change over time to point to different values';
-                    }
+            }
+            for (const dep of extra) {
+                if (dep.root.kind === 'Global') {
                     diagnostic.withDetails({
                         kind: 'error',
-                        message: `Missing dependency \`${printInferredDependency(dep)}\`${reactiveStableValueHint}`,
-                        loc: dep.loc,
+                        message: `Unnecessary dependency \`${printManualMemoDependency(dep)}\`. ` +
+                            'Values declared outside of a component/hook should not be listed as ' +
+                            'dependencies as the component will not re-render if they change',
+                        loc: (_e = (_d = dep.loc) !== null && _d !== void 0 ? _d : startMemo.depsLoc) !== null && _e !== void 0 ? _e : value.loc,
+                    });
+                    error.pushDiagnostic(diagnostic);
+                }
+                else {
+                    const root = dep.root.value;
+                    const matchingInferred = inferred.find((inferredDep) => {
+                        return (inferredDep.kind === 'Local' &&
+                            inferredDep.identifier.id === root.identifier.id &&
+                            isSubPathIgnoringOptionals(inferredDep.path, dep.path));
                     });
+                    if (matchingInferred != null &&
+                        !isOptionalDependency(matchingInferred, reactive)) {
+                        diagnostic.withDetails({
+                            kind: 'error',
+                            message: `Overly precise dependency \`${printManualMemoDependency(dep)}\`, ` +
+                                `use \`${printInferredDependency(matchingInferred)}\` instead`,
+                            loc: (_g = (_f = dep.loc) !== null && _f !== void 0 ? _f : startMemo.depsLoc) !== null && _g !== void 0 ? _g : value.loc,
+                        });
+                    }
+                    else {
+                        diagnostic.withDetails({
+                            kind: 'error',
+                            message: `Unnecessary dependency \`${printManualMemoDependency(dep)}\``,
+                            loc: (_j = (_h = dep.loc) !== null && _h !== void 0 ? _h : startMemo.depsLoc) !== null && _j !== void 0 ? _j : value.loc,
+                        });
+                    }
                 }
-                error.pushDiagnostic(diagnostic);
             }
-            else if (extra.length !== 0) {
-                const diagnostic = CompilerDiagnostic.create({
-                    category: ErrorCategory.MemoDependencies,
-                    reason: 'Found unnecessary memoization dependencies',
-                    description: 'Unnecessary dependencies can cause a value to update more often than necessary, ' +
-                        'which can cause effects to run more than expected',
-                });
+            if (suggestion != null) {
                 diagnostic.withDetails({
-                    kind: 'error',
-                    message: `Unnecessary dependencies ${extra.map(dep => `\`${printManualMemoDependency(dep)}\``).join(', ')}`,
-                    loc: (_d = startMemo.depsLoc) !== null && _d !== void 0 ? _d : value.loc,
+                    kind: 'hint',
+                    message: `Inferred dependencies: \`${suggestion.text}\``,
                 });
-                error.pushDiagnostic(diagnostic);
             }
+            error.pushDiagnostic(diagnostic);
         }
         dependencies.clear();
         locals.clear();
@@ -53817,6 +53900,11 @@ function findOptionalPlaces(fn) {
     }
     return optionals;
 }
+function isOptionalDependency(inferredDependency, reactive) {
+    return (!reactive.has(inferredDependency.identifier.id) &&
+        (isStableType(inferredDependency.identifier) ||
+            isPrimitiveType(inferredDependency.identifier)));
+}
 
 function run(func, config, fnType, mode, programContext, logger, filename, code) {
     var _a, _b;
@@ -53943,8 +54031,10 @@ function runWithEnvironment(func, env) {
     }
     inferReactivePlaces(hir);
     log({ kind: 'hir', name: 'InferReactivePlaces', value: hir });
-    if (env.config.validateExhaustiveMemoizationDependencies) {
-        validateExhaustiveDependencies(hir).unwrap();
+    if (env.enableValidations) {
+        if (env.config.validateExhaustiveMemoizationDependencies) {
+            validateExhaustiveDependencies(hir).unwrap();
+        }
     }
     rewriteInstructionKindsBasedOnReassignment(hir);
     log({
@@ -54207,7 +54297,7 @@ function findProgramSuppressions(programComments, ruleNames, flowSuppressions) {
     let disableNextLinePattern = null;
     let disablePattern = null;
     let enablePattern = null;
-    if (ruleNames.length !== 0) {
+    if (ruleNames != null && ruleNames.length !== 0) {
         const rulePattern = `(${ruleNames.join('|')})`;
         disableNextLinePattern = new RegExp(`eslint-disable-next-line ${rulePattern}`);
         disablePattern = new RegExp(`eslint-disable ${rulePattern}`);
@@ -54544,7 +54634,10 @@ function compileProgram(program, pass) {
         handleError(restrictedImportsErr, pass, null);
         return null;
     }
-    const suppressions = findProgramSuppressions(pass.comments, (_a = pass.opts.eslintSuppressionRules) !== null && _a !== void 0 ? _a : DEFAULT_ESLINT_SUPPRESSIONS, pass.opts.flowSuppressions);
+    const suppressions = findProgramSuppressions(pass.comments, pass.opts.environment.validateExhaustiveMemoizationDependencies &&
+        pass.opts.environment.validateHooksUsage
+        ? null
+        : ((_a = pass.opts.eslintSuppressionRules) !== null && _a !== void 0 ? _a : DEFAULT_ESLINT_SUPPRESSIONS), pass.opts.flowSuppressions);
     const programContext = new ProgramContext({
         program: program,
         opts: pass.opts,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "eslint-plugin-react-hooks",
   "description": "ESLint rules for React Hooks",
-  "version": "7.1.0-canary-fd524fe0-20251121",
+  "version": "7.1.0-canary-7dc903cd-20251203",
   "repository": {
     "type": "git",
     "url": "https://github.com/facebook/react.git",