eslint-plugin-react-hooks 7.0.0-canary-6160773f-20251023 → 7.0.1

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

@@ -17648,6 +17648,10 @@ function hasOwnProperty$1(obj, key) {
     return Object.prototype.hasOwnProperty.call(obj, key);
 }
 
+const CODEFRAME_LINES_ABOVE = 2;
+const CODEFRAME_LINES_BELOW = 3;
+const CODEFRAME_MAX_LINES = 10;
+const CODEFRAME_ABBREVIATED_SOURCE_LINES = 5;
 var ErrorSeverity;
 (function (ErrorSeverity) {
     ErrorSeverity["Error"] = "Error";
@@ -17964,7 +17968,7 @@ class CompilerError extends Error {
     }
 }
 function printCodeFrame(source, loc, message) {
-    return libExports.codeFrameColumns(source, {
+    const printed = libExports.codeFrameColumns(source, {
         start: {
             line: loc.start.line,
             column: loc.start.column + 1,
@@ -17975,7 +17979,19 @@ function printCodeFrame(source, loc, message) {
         },
     }, {
         message,
+        linesAbove: CODEFRAME_LINES_ABOVE,
+        linesBelow: CODEFRAME_LINES_BELOW,
     });
+    const lines = printed.split(/\r?\n/);
+    if (loc.end.line - loc.start.line < CODEFRAME_MAX_LINES) {
+        return printed;
+    }
+    const pipeIndex = lines[0].indexOf('|');
+    return [
+        ...lines.slice(0, CODEFRAME_LINES_ABOVE + CODEFRAME_ABBREVIATED_SOURCE_LINES),
+        ' '.repeat(pipeIndex) + '…',
+        ...lines.slice(-(CODEFRAME_LINES_BELOW + CODEFRAME_ABBREVIATED_SOURCE_LINES)),
+    ].join('\n');
 }
 function printErrorSummary(category, message) {
     let heading;
@@ -32096,6 +32112,7 @@ const EnvironmentConfigSchema = v4.z.object({
     validateNoSetStateInRender: v4.z.boolean().default(true),
     validateNoSetStateInEffects: v4.z.boolean().default(false),
     validateNoDerivedComputationsInEffects: v4.z.boolean().default(false),
+    validateNoDerivedComputationsInEffects_exp: v4.z.boolean().default(false),
     validateNoJSXInTryStatements: v4.z.boolean().default(false),
     validateStaticComponents: v4.z.boolean().default(false),
     validateMemoizedEffectDependencies: v4.z.boolean().default(false),
@@ -52038,7 +52055,7 @@ function validateNoDerivedComputationsInEffects(fn) {
                             });
                             return (_a = locals.get(dep.identifier.id)) !== null && _a !== void 0 ? _a : dep.identifier.id;
                         });
-                        validateEffect(effectFunction.loweredFunc.func, dependencies, errors);
+                        validateEffect$1(effectFunction.loweredFunc.func, dependencies, errors);
                     }
                 }
             }
@@ -52048,7 +52065,7 @@ function validateNoDerivedComputationsInEffects(fn) {
         throw errors;
     }
 }
-function validateEffect(effectFunction, effectDeps, errors) {
+function validateEffect$1(effectFunction, effectDeps, errors) {
     for (const operand of effectFunction.context) {
         if (isSetStateType(operand.identifier)) {
             continue;
@@ -52161,6 +52178,339 @@ function validateEffect(effectFunction, effectDeps, errors) {
     }
 }
 
+class DerivationCache {
+    constructor() {
+        this.hasChanges = false;
+        this.cache = new Map();
+    }
+    snapshot() {
+        const hasChanges = this.hasChanges;
+        this.hasChanges = false;
+        return hasChanges;
+    }
+    addDerivationEntry(derivedVar, sourcesIds, typeOfValue) {
+        var _a, _b;
+        let newValue = {
+            place: derivedVar,
+            sourcesIds: new Set(),
+            typeOfValue: typeOfValue !== null && typeOfValue !== void 0 ? typeOfValue : 'ignored',
+        };
+        if (sourcesIds !== undefined) {
+            for (const id of sourcesIds) {
+                const sourcePlace = (_a = this.cache.get(id)) === null || _a === void 0 ? void 0 : _a.place;
+                if (sourcePlace === undefined) {
+                    continue;
+                }
+                if (sourcePlace.identifier.name === null ||
+                    ((_b = sourcePlace.identifier.name) === null || _b === void 0 ? void 0 : _b.kind) === 'promoted') {
+                    newValue.sourcesIds.add(derivedVar.identifier.id);
+                }
+                else {
+                    newValue.sourcesIds.add(sourcePlace.identifier.id);
+                }
+            }
+        }
+        if (newValue.sourcesIds.size === 0) {
+            newValue.sourcesIds.add(derivedVar.identifier.id);
+        }
+        const existingValue = this.cache.get(derivedVar.identifier.id);
+        if (existingValue === undefined ||
+            !this.isDerivationEqual(existingValue, newValue)) {
+            this.cache.set(derivedVar.identifier.id, newValue);
+            this.hasChanges = true;
+        }
+    }
+    isDerivationEqual(a, b) {
+        if (a.typeOfValue !== b.typeOfValue) {
+            return false;
+        }
+        if (a.sourcesIds.size !== b.sourcesIds.size) {
+            return false;
+        }
+        for (const id of a.sourcesIds) {
+            if (!b.sourcesIds.has(id)) {
+                return false;
+            }
+        }
+        return true;
+    }
+}
+function validateNoDerivedComputationsInEffects_exp(fn) {
+    const functions = new Map();
+    const derivationCache = new DerivationCache();
+    const errors = new CompilerError();
+    const effects = new Set();
+    const setStateCache = new Map();
+    const effectSetStateCache = new Map();
+    const context = {
+        functions,
+        errors,
+        derivationCache,
+        effects,
+        setStateCache,
+        effectSetStateCache,
+    };
+    if (fn.fnType === 'Hook') {
+        for (const param of fn.params) {
+            if (param.kind === 'Identifier') {
+                context.derivationCache.cache.set(param.identifier.id, {
+                    place: param,
+                    sourcesIds: new Set([param.identifier.id]),
+                    typeOfValue: 'fromProps',
+                });
+                context.derivationCache.hasChanges = true;
+            }
+        }
+    }
+    else if (fn.fnType === 'Component') {
+        const props = fn.params[0];
+        if (props != null && props.kind === 'Identifier') {
+            context.derivationCache.cache.set(props.identifier.id, {
+                place: props,
+                sourcesIds: new Set([props.identifier.id]),
+                typeOfValue: 'fromProps',
+            });
+            context.derivationCache.hasChanges = true;
+        }
+    }
+    let isFirstPass = true;
+    do {
+        for (const block of fn.body.blocks.values()) {
+            recordPhiDerivations(block, context);
+            for (const instr of block.instructions) {
+                recordInstructionDerivations(instr, context, isFirstPass);
+            }
+        }
+        isFirstPass = false;
+    } while (context.derivationCache.snapshot());
+    for (const effect of effects) {
+        validateEffect(effect, context);
+    }
+    if (errors.hasAnyErrors()) {
+        throw errors;
+    }
+}
+function recordPhiDerivations(block, context) {
+    for (const phi of block.phis) {
+        let typeOfValue = 'ignored';
+        let sourcesIds = new Set();
+        for (const operand of phi.operands.values()) {
+            const operandMetadata = context.derivationCache.cache.get(operand.identifier.id);
+            if (operandMetadata === undefined) {
+                continue;
+            }
+            typeOfValue = joinValue(typeOfValue, operandMetadata.typeOfValue);
+            sourcesIds.add(operand.identifier.id);
+        }
+        if (typeOfValue !== 'ignored') {
+            context.derivationCache.addDerivationEntry(phi.place, sourcesIds, typeOfValue);
+        }
+    }
+}
+function joinValue(lvalueType, valueType) {
+    if (lvalueType === 'ignored')
+        return valueType;
+    if (valueType === 'ignored')
+        return lvalueType;
+    if (lvalueType === valueType)
+        return lvalueType;
+    return 'fromPropsAndState';
+}
+function recordInstructionDerivations(instr, context, isFirstPass) {
+    let typeOfValue = 'ignored';
+    const sources = new Set();
+    const { lvalue, value } = instr;
+    if (value.kind === 'FunctionExpression') {
+        context.functions.set(lvalue.identifier.id, value);
+        for (const [, block] of value.loweredFunc.func.body.blocks) {
+            for (const instr of block.instructions) {
+                recordInstructionDerivations(instr, context, isFirstPass);
+            }
+        }
+    }
+    else if (value.kind === 'CallExpression' || value.kind === 'MethodCall') {
+        const callee = value.kind === 'CallExpression' ? value.callee : value.property;
+        if (isUseEffectHookType(callee.identifier) &&
+            value.args.length === 2 &&
+            value.args[0].kind === 'Identifier' &&
+            value.args[1].kind === 'Identifier') {
+            const effectFunction = context.functions.get(value.args[0].identifier.id);
+            if (effectFunction != null) {
+                context.effects.add(effectFunction.loweredFunc.func);
+            }
+        }
+        else if (isUseStateType(lvalue.identifier) && value.args.length > 0) {
+            const stateValueSource = value.args[0];
+            if (stateValueSource.kind === 'Identifier') {
+                sources.add(stateValueSource.identifier.id);
+            }
+            typeOfValue = joinValue(typeOfValue, 'fromState');
+        }
+    }
+    for (const operand of eachInstructionOperand(instr)) {
+        if (isSetStateType(operand.identifier) &&
+            operand.loc !== GeneratedSource &&
+            isFirstPass) {
+            if (context.setStateCache.has(operand.loc.identifierName)) {
+                context.setStateCache.get(operand.loc.identifierName).push(operand);
+            }
+            else {
+                context.setStateCache.set(operand.loc.identifierName, [operand]);
+            }
+        }
+        const operandMetadata = context.derivationCache.cache.get(operand.identifier.id);
+        if (operandMetadata === undefined) {
+            continue;
+        }
+        typeOfValue = joinValue(typeOfValue, operandMetadata.typeOfValue);
+        for (const id of operandMetadata.sourcesIds) {
+            sources.add(id);
+        }
+    }
+    if (typeOfValue === 'ignored') {
+        return;
+    }
+    for (const lvalue of eachInstructionLValue(instr)) {
+        context.derivationCache.addDerivationEntry(lvalue, sources, typeOfValue);
+    }
+    for (const operand of eachInstructionOperand(instr)) {
+        switch (operand.effect) {
+            case Effect.Capture:
+            case Effect.Store:
+            case Effect.ConditionallyMutate:
+            case Effect.ConditionallyMutateIterator:
+            case Effect.Mutate: {
+                if (isMutable(instr, operand)) {
+                    context.derivationCache.addDerivationEntry(operand, sources, typeOfValue);
+                }
+                break;
+            }
+            case Effect.Freeze:
+            case Effect.Read: {
+                break;
+            }
+            case Effect.Unknown: {
+                CompilerError.invariant(false, {
+                    reason: 'Unexpected unknown effect',
+                    description: null,
+                    details: [
+                        {
+                            kind: 'error',
+                            loc: operand.loc,
+                            message: 'Unexpected unknown effect',
+                        },
+                    ],
+                });
+            }
+            default: {
+                assertExhaustive$1(operand.effect, `Unexpected effect kind \`${operand.effect}\``);
+            }
+        }
+    }
+}
+function validateEffect(effectFunction, context) {
+    const seenBlocks = new Set();
+    const effectDerivedSetStateCalls = [];
+    const globals = new Set();
+    for (const block of effectFunction.body.blocks.values()) {
+        for (const pred of block.preds) {
+            if (!seenBlocks.has(pred)) {
+                return;
+            }
+        }
+        for (const instr of block.instructions) {
+            if (isUseRefType(instr.lvalue.identifier)) {
+                return;
+            }
+            for (const operand of eachInstructionOperand(instr)) {
+                if (isSetStateType(operand.identifier) &&
+                    operand.loc !== GeneratedSource) {
+                    if (context.effectSetStateCache.has(operand.loc.identifierName)) {
+                        context.effectSetStateCache
+                            .get(operand.loc.identifierName)
+                            .push(operand);
+                    }
+                    else {
+                        context.effectSetStateCache.set(operand.loc.identifierName, [
+                            operand,
+                        ]);
+                    }
+                }
+            }
+            if (instr.value.kind === 'CallExpression' &&
+                isSetStateType(instr.value.callee.identifier) &&
+                instr.value.args.length === 1 &&
+                instr.value.args[0].kind === 'Identifier') {
+                const argMetadata = context.derivationCache.cache.get(instr.value.args[0].identifier.id);
+                if (argMetadata !== undefined) {
+                    effectDerivedSetStateCalls.push({
+                        value: instr.value,
+                        loc: instr.value.callee.loc,
+                        sourceIds: argMetadata.sourcesIds,
+                        typeOfValue: argMetadata.typeOfValue,
+                    });
+                }
+            }
+            else if (instr.value.kind === 'CallExpression') {
+                const calleeMetadata = context.derivationCache.cache.get(instr.value.callee.identifier.id);
+                if (calleeMetadata !== undefined &&
+                    (calleeMetadata.typeOfValue === 'fromProps' ||
+                        calleeMetadata.typeOfValue === 'fromPropsAndState')) {
+                    return;
+                }
+                if (globals.has(instr.value.callee.identifier.id)) {
+                    return;
+                }
+            }
+            else if (instr.value.kind === 'LoadGlobal') {
+                globals.add(instr.lvalue.identifier.id);
+                for (const operand of eachInstructionOperand(instr)) {
+                    globals.add(operand.identifier.id);
+                }
+            }
+        }
+        seenBlocks.add(block.id);
+    }
+    for (const derivedSetStateCall of effectDerivedSetStateCalls) {
+        if (derivedSetStateCall.loc !== GeneratedSource &&
+            context.effectSetStateCache.has(derivedSetStateCall.loc.identifierName) &&
+            context.setStateCache.has(derivedSetStateCall.loc.identifierName) &&
+            context.effectSetStateCache.get(derivedSetStateCall.loc.identifierName)
+                .length ===
+                context.setStateCache.get(derivedSetStateCall.loc.identifierName)
+                    .length -
+                    1) {
+            const derivedDepsStr = Array.from(derivedSetStateCall.sourceIds)
+                .map(sourceId => {
+                var _a;
+                const sourceMetadata = context.derivationCache.cache.get(sourceId);
+                return (_a = sourceMetadata === null || sourceMetadata === void 0 ? void 0 : sourceMetadata.place.identifier.name) === null || _a === void 0 ? void 0 : _a.value;
+            })
+                .filter(Boolean)
+                .join(', ');
+            let description;
+            if (derivedSetStateCall.typeOfValue === 'fromProps') {
+                description = `From props: [${derivedDepsStr}]`;
+            }
+            else if (derivedSetStateCall.typeOfValue === 'fromState') {
+                description = `From local state: [${derivedDepsStr}]`;
+            }
+            else {
+                description = `From props and local state: [${derivedDepsStr}]`;
+            }
+            context.errors.pushDiagnostic(CompilerDiagnostic.create({
+                description: `Derived values (${description}) should be computed during render, rather than in effects. Using an effect triggers an additional render which can hurt performance and user experience, potentially briefly showing stale values to the user`,
+                category: ErrorCategory.EffectDerivationsOfState,
+                reason: 'You might not need an effect. Derive values in render, not effects.',
+            }).withDetails({
+                kind: 'error',
+                loc: derivedSetStateCall.value.callee.loc,
+                message: 'This should be computed during render, not in an effect',
+            }));
+        }
+    }
+}
+
 function nameAnonymousFunctions(fn) {
     if (fn.id == null) {
         return;
@@ -52402,6 +52752,9 @@ function runWithEnvironment(func, env) {
         if (env.config.validateNoDerivedComputationsInEffects) {
             validateNoDerivedComputationsInEffects(hir);
         }
+        if (env.config.validateNoDerivedComputationsInEffects_exp) {
+            validateNoDerivedComputationsInEffects_exp(hir);
+        }
         if (env.config.validateNoSetStateInEffects) {
             env.logErrors(validateNoSetStateInEffects(hir, env));
         }

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

@@ -17639,6 +17639,10 @@ function hasOwnProperty$1(obj, key) {
     return Object.prototype.hasOwnProperty.call(obj, key);
 }
 
+const CODEFRAME_LINES_ABOVE = 2;
+const CODEFRAME_LINES_BELOW = 3;
+const CODEFRAME_MAX_LINES = 10;
+const CODEFRAME_ABBREVIATED_SOURCE_LINES = 5;
 var ErrorSeverity;
 (function (ErrorSeverity) {
     ErrorSeverity["Error"] = "Error";
@@ -17955,7 +17959,7 @@ class CompilerError extends Error {
     }
 }
 function printCodeFrame(source, loc, message) {
-    return libExports.codeFrameColumns(source, {
+    const printed = libExports.codeFrameColumns(source, {
         start: {
             line: loc.start.line,
             column: loc.start.column + 1,
@@ -17966,7 +17970,19 @@ function printCodeFrame(source, loc, message) {
         },
     }, {
         message,
+        linesAbove: CODEFRAME_LINES_ABOVE,
+        linesBelow: CODEFRAME_LINES_BELOW,
     });
+    const lines = printed.split(/\r?\n/);
+    if (loc.end.line - loc.start.line < CODEFRAME_MAX_LINES) {
+        return printed;
+    }
+    const pipeIndex = lines[0].indexOf('|');
+    return [
+        ...lines.slice(0, CODEFRAME_LINES_ABOVE + CODEFRAME_ABBREVIATED_SOURCE_LINES),
+        ' '.repeat(pipeIndex) + '…',
+        ...lines.slice(-(CODEFRAME_LINES_BELOW + CODEFRAME_ABBREVIATED_SOURCE_LINES)),
+    ].join('\n');
 }
 function printErrorSummary(category, message) {
     let heading;
@@ -31923,6 +31939,7 @@ const EnvironmentConfigSchema = v4.z.object({
     validateNoSetStateInRender: v4.z.boolean().default(true),
     validateNoSetStateInEffects: v4.z.boolean().default(false),
     validateNoDerivedComputationsInEffects: v4.z.boolean().default(false),
+    validateNoDerivedComputationsInEffects_exp: v4.z.boolean().default(false),
     validateNoJSXInTryStatements: v4.z.boolean().default(false),
     validateStaticComponents: v4.z.boolean().default(false),
     validateMemoizedEffectDependencies: v4.z.boolean().default(false),
@@ -51865,7 +51882,7 @@ function validateNoDerivedComputationsInEffects(fn) {
                             });
                             return (_a = locals.get(dep.identifier.id)) !== null && _a !== void 0 ? _a : dep.identifier.id;
                         });
-                        validateEffect(effectFunction.loweredFunc.func, dependencies, errors);
+                        validateEffect$1(effectFunction.loweredFunc.func, dependencies, errors);
                     }
                 }
             }
@@ -51875,7 +51892,7 @@ function validateNoDerivedComputationsInEffects(fn) {
         throw errors;
     }
 }
-function validateEffect(effectFunction, effectDeps, errors) {
+function validateEffect$1(effectFunction, effectDeps, errors) {
     for (const operand of effectFunction.context) {
         if (isSetStateType(operand.identifier)) {
             continue;
@@ -51988,6 +52005,339 @@ function validateEffect(effectFunction, effectDeps, errors) {
     }
 }
 
+class DerivationCache {
+    constructor() {
+        this.hasChanges = false;
+        this.cache = new Map();
+    }
+    snapshot() {
+        const hasChanges = this.hasChanges;
+        this.hasChanges = false;
+        return hasChanges;
+    }
+    addDerivationEntry(derivedVar, sourcesIds, typeOfValue) {
+        var _a, _b;
+        let newValue = {
+            place: derivedVar,
+            sourcesIds: new Set(),
+            typeOfValue: typeOfValue !== null && typeOfValue !== void 0 ? typeOfValue : 'ignored',
+        };
+        if (sourcesIds !== undefined) {
+            for (const id of sourcesIds) {
+                const sourcePlace = (_a = this.cache.get(id)) === null || _a === void 0 ? void 0 : _a.place;
+                if (sourcePlace === undefined) {
+                    continue;
+                }
+                if (sourcePlace.identifier.name === null ||
+                    ((_b = sourcePlace.identifier.name) === null || _b === void 0 ? void 0 : _b.kind) === 'promoted') {
+                    newValue.sourcesIds.add(derivedVar.identifier.id);
+                }
+                else {
+                    newValue.sourcesIds.add(sourcePlace.identifier.id);
+                }
+            }
+        }
+        if (newValue.sourcesIds.size === 0) {
+            newValue.sourcesIds.add(derivedVar.identifier.id);
+        }
+        const existingValue = this.cache.get(derivedVar.identifier.id);
+        if (existingValue === undefined ||
+            !this.isDerivationEqual(existingValue, newValue)) {
+            this.cache.set(derivedVar.identifier.id, newValue);
+            this.hasChanges = true;
+        }
+    }
+    isDerivationEqual(a, b) {
+        if (a.typeOfValue !== b.typeOfValue) {
+            return false;
+        }
+        if (a.sourcesIds.size !== b.sourcesIds.size) {
+            return false;
+        }
+        for (const id of a.sourcesIds) {
+            if (!b.sourcesIds.has(id)) {
+                return false;
+            }
+        }
+        return true;
+    }
+}
+function validateNoDerivedComputationsInEffects_exp(fn) {
+    const functions = new Map();
+    const derivationCache = new DerivationCache();
+    const errors = new CompilerError();
+    const effects = new Set();
+    const setStateCache = new Map();
+    const effectSetStateCache = new Map();
+    const context = {
+        functions,
+        errors,
+        derivationCache,
+        effects,
+        setStateCache,
+        effectSetStateCache,
+    };
+    if (fn.fnType === 'Hook') {
+        for (const param of fn.params) {
+            if (param.kind === 'Identifier') {
+                context.derivationCache.cache.set(param.identifier.id, {
+                    place: param,
+                    sourcesIds: new Set([param.identifier.id]),
+                    typeOfValue: 'fromProps',
+                });
+                context.derivationCache.hasChanges = true;
+            }
+        }
+    }
+    else if (fn.fnType === 'Component') {
+        const props = fn.params[0];
+        if (props != null && props.kind === 'Identifier') {
+            context.derivationCache.cache.set(props.identifier.id, {
+                place: props,
+                sourcesIds: new Set([props.identifier.id]),
+                typeOfValue: 'fromProps',
+            });
+            context.derivationCache.hasChanges = true;
+        }
+    }
+    let isFirstPass = true;
+    do {
+        for (const block of fn.body.blocks.values()) {
+            recordPhiDerivations(block, context);
+            for (const instr of block.instructions) {
+                recordInstructionDerivations(instr, context, isFirstPass);
+            }
+        }
+        isFirstPass = false;
+    } while (context.derivationCache.snapshot());
+    for (const effect of effects) {
+        validateEffect(effect, context);
+    }
+    if (errors.hasAnyErrors()) {
+        throw errors;
+    }
+}
+function recordPhiDerivations(block, context) {
+    for (const phi of block.phis) {
+        let typeOfValue = 'ignored';
+        let sourcesIds = new Set();
+        for (const operand of phi.operands.values()) {
+            const operandMetadata = context.derivationCache.cache.get(operand.identifier.id);
+            if (operandMetadata === undefined) {
+                continue;
+            }
+            typeOfValue = joinValue(typeOfValue, operandMetadata.typeOfValue);
+            sourcesIds.add(operand.identifier.id);
+        }
+        if (typeOfValue !== 'ignored') {
+            context.derivationCache.addDerivationEntry(phi.place, sourcesIds, typeOfValue);
+        }
+    }
+}
+function joinValue(lvalueType, valueType) {
+    if (lvalueType === 'ignored')
+        return valueType;
+    if (valueType === 'ignored')
+        return lvalueType;
+    if (lvalueType === valueType)
+        return lvalueType;
+    return 'fromPropsAndState';
+}
+function recordInstructionDerivations(instr, context, isFirstPass) {
+    let typeOfValue = 'ignored';
+    const sources = new Set();
+    const { lvalue, value } = instr;
+    if (value.kind === 'FunctionExpression') {
+        context.functions.set(lvalue.identifier.id, value);
+        for (const [, block] of value.loweredFunc.func.body.blocks) {
+            for (const instr of block.instructions) {
+                recordInstructionDerivations(instr, context, isFirstPass);
+            }
+        }
+    }
+    else if (value.kind === 'CallExpression' || value.kind === 'MethodCall') {
+        const callee = value.kind === 'CallExpression' ? value.callee : value.property;
+        if (isUseEffectHookType(callee.identifier) &&
+            value.args.length === 2 &&
+            value.args[0].kind === 'Identifier' &&
+            value.args[1].kind === 'Identifier') {
+            const effectFunction = context.functions.get(value.args[0].identifier.id);
+            if (effectFunction != null) {
+                context.effects.add(effectFunction.loweredFunc.func);
+            }
+        }
+        else if (isUseStateType(lvalue.identifier) && value.args.length > 0) {
+            const stateValueSource = value.args[0];
+            if (stateValueSource.kind === 'Identifier') {
+                sources.add(stateValueSource.identifier.id);
+            }
+            typeOfValue = joinValue(typeOfValue, 'fromState');
+        }
+    }
+    for (const operand of eachInstructionOperand(instr)) {
+        if (isSetStateType(operand.identifier) &&
+            operand.loc !== GeneratedSource &&
+            isFirstPass) {
+            if (context.setStateCache.has(operand.loc.identifierName)) {
+                context.setStateCache.get(operand.loc.identifierName).push(operand);
+            }
+            else {
+                context.setStateCache.set(operand.loc.identifierName, [operand]);
+            }
+        }
+        const operandMetadata = context.derivationCache.cache.get(operand.identifier.id);
+        if (operandMetadata === undefined) {
+            continue;
+        }
+        typeOfValue = joinValue(typeOfValue, operandMetadata.typeOfValue);
+        for (const id of operandMetadata.sourcesIds) {
+            sources.add(id);
+        }
+    }
+    if (typeOfValue === 'ignored') {
+        return;
+    }
+    for (const lvalue of eachInstructionLValue(instr)) {
+        context.derivationCache.addDerivationEntry(lvalue, sources, typeOfValue);
+    }
+    for (const operand of eachInstructionOperand(instr)) {
+        switch (operand.effect) {
+            case Effect.Capture:
+            case Effect.Store:
+            case Effect.ConditionallyMutate:
+            case Effect.ConditionallyMutateIterator:
+            case Effect.Mutate: {
+                if (isMutable(instr, operand)) {
+                    context.derivationCache.addDerivationEntry(operand, sources, typeOfValue);
+                }
+                break;
+            }
+            case Effect.Freeze:
+            case Effect.Read: {
+                break;
+            }
+            case Effect.Unknown: {
+                CompilerError.invariant(false, {
+                    reason: 'Unexpected unknown effect',
+                    description: null,
+                    details: [
+                        {
+                            kind: 'error',
+                            loc: operand.loc,
+                            message: 'Unexpected unknown effect',
+                        },
+                    ],
+                });
+            }
+            default: {
+                assertExhaustive$1(operand.effect, `Unexpected effect kind \`${operand.effect}\``);
+            }
+        }
+    }
+}
+function validateEffect(effectFunction, context) {
+    const seenBlocks = new Set();
+    const effectDerivedSetStateCalls = [];
+    const globals = new Set();
+    for (const block of effectFunction.body.blocks.values()) {
+        for (const pred of block.preds) {
+            if (!seenBlocks.has(pred)) {
+                return;
+            }
+        }
+        for (const instr of block.instructions) {
+            if (isUseRefType(instr.lvalue.identifier)) {
+                return;
+            }
+            for (const operand of eachInstructionOperand(instr)) {
+                if (isSetStateType(operand.identifier) &&
+                    operand.loc !== GeneratedSource) {
+                    if (context.effectSetStateCache.has(operand.loc.identifierName)) {
+                        context.effectSetStateCache
+                            .get(operand.loc.identifierName)
+                            .push(operand);
+                    }
+                    else {
+                        context.effectSetStateCache.set(operand.loc.identifierName, [
+                            operand,
+                        ]);
+                    }
+                }
+            }
+            if (instr.value.kind === 'CallExpression' &&
+                isSetStateType(instr.value.callee.identifier) &&
+                instr.value.args.length === 1 &&
+                instr.value.args[0].kind === 'Identifier') {
+                const argMetadata = context.derivationCache.cache.get(instr.value.args[0].identifier.id);
+                if (argMetadata !== undefined) {
+                    effectDerivedSetStateCalls.push({
+                        value: instr.value,
+                        loc: instr.value.callee.loc,
+                        sourceIds: argMetadata.sourcesIds,
+                        typeOfValue: argMetadata.typeOfValue,
+                    });
+                }
+            }
+            else if (instr.value.kind === 'CallExpression') {
+                const calleeMetadata = context.derivationCache.cache.get(instr.value.callee.identifier.id);
+                if (calleeMetadata !== undefined &&
+                    (calleeMetadata.typeOfValue === 'fromProps' ||
+                        calleeMetadata.typeOfValue === 'fromPropsAndState')) {
+                    return;
+                }
+                if (globals.has(instr.value.callee.identifier.id)) {
+                    return;
+                }
+            }
+            else if (instr.value.kind === 'LoadGlobal') {
+                globals.add(instr.lvalue.identifier.id);
+                for (const operand of eachInstructionOperand(instr)) {
+                    globals.add(operand.identifier.id);
+                }
+            }
+        }
+        seenBlocks.add(block.id);
+    }
+    for (const derivedSetStateCall of effectDerivedSetStateCalls) {
+        if (derivedSetStateCall.loc !== GeneratedSource &&
+            context.effectSetStateCache.has(derivedSetStateCall.loc.identifierName) &&
+            context.setStateCache.has(derivedSetStateCall.loc.identifierName) &&
+            context.effectSetStateCache.get(derivedSetStateCall.loc.identifierName)
+                .length ===
+                context.setStateCache.get(derivedSetStateCall.loc.identifierName)
+                    .length -
+                    1) {
+            const derivedDepsStr = Array.from(derivedSetStateCall.sourceIds)
+                .map(sourceId => {
+                var _a;
+                const sourceMetadata = context.derivationCache.cache.get(sourceId);
+                return (_a = sourceMetadata === null || sourceMetadata === void 0 ? void 0 : sourceMetadata.place.identifier.name) === null || _a === void 0 ? void 0 : _a.value;
+            })
+                .filter(Boolean)
+                .join(', ');
+            let description;
+            if (derivedSetStateCall.typeOfValue === 'fromProps') {
+                description = `From props: [${derivedDepsStr}]`;
+            }
+            else if (derivedSetStateCall.typeOfValue === 'fromState') {
+                description = `From local state: [${derivedDepsStr}]`;
+            }
+            else {
+                description = `From props and local state: [${derivedDepsStr}]`;
+            }
+            context.errors.pushDiagnostic(CompilerDiagnostic.create({
+                description: `Derived values (${description}) should be computed during render, rather than in effects. Using an effect triggers an additional render which can hurt performance and user experience, potentially briefly showing stale values to the user`,
+                category: ErrorCategory.EffectDerivationsOfState,
+                reason: 'You might not need an effect. Derive values in render, not effects.',
+            }).withDetails({
+                kind: 'error',
+                loc: derivedSetStateCall.value.callee.loc,
+                message: 'This should be computed during render, not in an effect',
+            }));
+        }
+    }
+}
+
 function nameAnonymousFunctions(fn) {
     if (fn.id == null) {
         return;
@@ -52229,6 +52579,9 @@ function runWithEnvironment(func, env) {
         if (env.config.validateNoDerivedComputationsInEffects) {
             validateNoDerivedComputationsInEffects(hir);
         }
+        if (env.config.validateNoDerivedComputationsInEffects_exp) {
+            validateNoDerivedComputationsInEffects_exp(hir);
+        }
         if (env.config.validateNoSetStateInEffects) {
             env.logErrors(validateNoSetStateInEffects(hir, env));
         }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "eslint-plugin-react-hooks",
   "description": "ESLint rules for React Hooks",
-  "version": "7.0.0-canary-6160773f-20251023",
+  "version": "7.0.1",
   "repository": {
     "type": "git",
     "url": "https://github.com/facebook/react.git",
@@ -65,4 +65,4 @@
     "jest": "^29.5.0",
     "typescript": "^5.4.3"
   }
-}
+}