eslint-plugin-react-hooks 7.1.0-canary-257b033f-20251113 → 7.1.0-canary-0972e239-20251118

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

@@ -18957,9 +18957,18 @@ function isRefOrRefLikeMutableType(type) {
 function isSetStateType(id) {
     return id.type.kind === 'Function' && id.type.shapeId === 'BuiltInSetState';
 }
+function isUseActionStateType(id) {
+    return (id.type.kind === 'Object' && id.type.shapeId === 'BuiltInUseActionState');
+}
 function isStartTransitionType(id) {
     return (id.type.kind === 'Function' && id.type.shapeId === 'BuiltInStartTransition');
 }
+function isUseOptimisticType(id) {
+    return (id.type.kind === 'Object' && id.type.shapeId === 'BuiltInUseOptimistic');
+}
+function isSetOptimisticType(id) {
+    return (id.type.kind === 'Function' && id.type.shapeId === 'BuiltInSetOptimistic');
+}
 function isSetActionStateType(id) {
     return (id.type.kind === 'Function' && id.type.shapeId === 'BuiltInSetActionState');
 }
@@ -18981,7 +18990,8 @@ function isStableType(id) {
         isSetActionStateType(id) ||
         isDispatcherType(id) ||
         isUseRefType(id) ||
-        isStartTransitionType(id));
+        isStartTransitionType(id) ||
+        isSetOptimisticType(id));
 }
 function isStableTypeContainer(id) {
     const type_ = id.type;
@@ -18989,8 +18999,9 @@ function isStableTypeContainer(id) {
         return false;
     }
     return (isUseStateType(id) ||
-        type_.shapeId === 'BuiltInUseActionState' ||
+        isUseActionStateType(id) ||
         isUseReducerType(id) ||
+        isUseOptimisticType(id) ||
         type_.shapeId === 'BuiltInUseTransition');
 }
 function evaluatesToStableTypeOrContainer(env, { value }) {
@@ -19003,6 +19014,7 @@ function evaluatesToStableTypeOrContainer(env, { value }) {
             case 'useActionState':
             case 'useRef':
             case 'useTransition':
+            case 'useOptimistic':
                 return true;
         }
     }
@@ -19851,6 +19863,29 @@ function* eachInstructionLValue(instr) {
     }
     yield* eachInstructionValueLValue(instr.value);
 }
+function* eachInstructionLValueWithKind(instr) {
+    switch (instr.value.kind) {
+        case 'DeclareContext':
+        case 'StoreContext':
+        case 'DeclareLocal':
+        case 'StoreLocal': {
+            yield [instr.value.lvalue.place, instr.value.lvalue.kind];
+            break;
+        }
+        case 'Destructure': {
+            const kind = instr.value.lvalue.kind;
+            for (const place of eachPatternOperand(instr.value.lvalue.pattern)) {
+                yield [place, kind];
+            }
+            break;
+        }
+        case 'PostfixUpdate':
+        case 'PrefixUpdate': {
+            yield [instr.value.lvalue, InstructionKind.Reassign];
+            break;
+        }
+    }
+}
 function* eachInstructionValueLValue(value) {
     switch (value.kind) {
         case 'DeclareContext':
@@ -22081,12 +22116,15 @@ const BuiltInUseReducerId = 'BuiltInUseReducer';
 const BuiltInDispatchId = 'BuiltInDispatch';
 const BuiltInUseContextHookId = 'BuiltInUseContextHook';
 const BuiltInUseTransitionId = 'BuiltInUseTransition';
+const BuiltInUseOptimisticId = 'BuiltInUseOptimistic';
+const BuiltInSetOptimisticId = 'BuiltInSetOptimistic';
 const BuiltInStartTransitionId = 'BuiltInStartTransition';
 const BuiltInFireId = 'BuiltInFire';
 const BuiltInFireFunctionId = 'BuiltInFireFunction';
 const BuiltInUseEffectEventId = 'BuiltInUseEffectEvent';
-const BuiltinEffectEventId = 'BuiltInEffectEventFunction';
+const BuiltInEffectEventId = 'BuiltInEffectEventFunction';
 const BuiltInAutodepsId = 'BuiltInAutoDepsId';
+const BuiltInEventHandlerId = 'BuiltInEventHandlerId';
 const ReanimatedSharedValueId = 'ReanimatedSharedValueId';
 const BUILTIN_SHAPES = new Map();
 addObject(BUILTIN_SHAPES, BuiltInPropsId, [
@@ -22694,6 +22732,19 @@ addObject(BUILTIN_SHAPES, BuiltInUseTransitionId, [
         }, BuiltInStartTransitionId),
     ],
 ]);
+addObject(BUILTIN_SHAPES, BuiltInUseOptimisticId, [
+    ['0', { kind: 'Poly' }],
+    [
+        '1',
+        addFunction(BUILTIN_SHAPES, [], {
+            positionalParams: [],
+            restParam: Effect.Freeze,
+            returnType: PRIMITIVE_TYPE,
+            calleeEffect: Effect.Read,
+            returnValueKind: ValueKind.Primitive,
+        }, BuiltInSetOptimisticId),
+    ],
+]);
 addObject(BUILTIN_SHAPES, BuiltInUseActionStateId, [
     ['0', { kind: 'Poly' }],
     [
@@ -22733,7 +22784,14 @@ addFunction(BUILTIN_SHAPES, [], {
     returnType: { kind: 'Poly' },
     calleeEffect: Effect.ConditionallyMutate,
     returnValueKind: ValueKind.Mutable,
-}, BuiltinEffectEventId);
+}, BuiltInEffectEventId);
+addFunction(BUILTIN_SHAPES, [], {
+    positionalParams: [],
+    restParam: Effect.ConditionallyMutate,
+    returnType: { kind: 'Poly' },
+    calleeEffect: Effect.ConditionallyMutate,
+    returnValueKind: ValueKind.Mutable,
+}, BuiltInEventHandlerId);
 addObject(BUILTIN_SHAPES, BuiltInMixedReadonlyId, [
     [
         'toString',
@@ -31088,6 +31146,18 @@ const REACT_APIS = [
             returnValueKind: ValueKind.Frozen,
         }),
     ],
+    [
+        'useOptimistic',
+        addHook(DEFAULT_SHAPES, {
+            positionalParams: [],
+            restParam: Effect.Freeze,
+            returnType: { kind: 'Object', shapeId: BuiltInUseOptimisticId },
+            calleeEffect: Effect.Read,
+            hookKind: 'useOptimistic',
+            returnValueKind: ValueKind.Frozen,
+            returnValueReason: ValueReason.State,
+        }),
+    ],
     [
         'use',
         addFunction(DEFAULT_SHAPES, [], {
@@ -31121,7 +31191,7 @@ const REACT_APIS = [
             returnType: {
                 kind: 'Function',
                 return: { kind: 'Poly' },
-                shapeId: BuiltinEffectEventId,
+                shapeId: BuiltInEffectEventId,
                 isConstructor: false,
             },
             calleeEffect: Effect.Read,
@@ -32144,6 +32214,7 @@ const EnvironmentConfigSchema = v4.z.object({
     validateNoVoidUseMemo: v4.z.boolean().default(true),
     validateNoDynamicallyCreatedComponentsOrHooks: v4.z.boolean().default(false),
     enableAllowSetStateFromRefsInEffects: v4.z.boolean().default(true),
+    enableInferEventHandlers: v4.z.boolean().default(false),
 });
 class Environment {
     constructor(scope, fnType, compilerMode, config, contextIdentifiers, parentFunction, logger, filename, code, programContext) {
@@ -38115,33 +38186,11 @@ function codegenInstructionNullable(cx, instr) {
         }
         else {
             lvalue = instr.value.lvalue.pattern;
-            let hasReassign = false;
-            let hasDeclaration = false;
             for (const place of eachPatternOperand(lvalue)) {
                 if (kind !== InstructionKind.Reassign &&
                     place.identifier.name === null) {
                     cx.temp.set(place.identifier.declarationId, null);
                 }
-                const isDeclared = cx.hasDeclared(place.identifier);
-                hasReassign || (hasReassign = isDeclared);
-                hasDeclaration || (hasDeclaration = !isDeclared);
-            }
-            if (hasReassign && hasDeclaration) {
-                CompilerError.invariant(false, {
-                    reason: 'Encountered a destructuring operation where some identifiers are already declared (reassignments) but others are not (declarations)',
-                    description: null,
-                    details: [
-                        {
-                            kind: 'error',
-                            loc: instr.loc,
-                            message: null,
-                        },
-                    ],
-                    suggestions: null,
-                });
-            }
-            else if (hasReassign) {
-                kind = InstructionKind.Reassign;
             }
             value = codegenPlaceToExpression(cx, instr.value.value);
         }
@@ -39345,10 +39394,13 @@ let Visitor$9 = class Visitor extends ReactiveFunctionTransform {
     }
     transformInstruction(instruction, state) {
         this.visitInstruction(instruction, state);
+        let instructionsToProcess = [instruction];
+        let result = { kind: 'keep' };
         if (instruction.value.kind === 'Destructure') {
             const transformed = transformDestructuring(state, instruction, instruction.value);
             if (transformed) {
-                return {
+                instructionsToProcess = transformed;
+                result = {
                     kind: 'replace-many',
                     value: transformed.map(instruction => ({
                         kind: 'instruction',
@@ -39357,7 +39409,14 @@ let Visitor$9 = class Visitor extends ReactiveFunctionTransform {
                 };
             }
         }
-        return { kind: 'keep' };
+        for (const instr of instructionsToProcess) {
+            for (const [place, kind] of eachInstructionLValueWithKind(instr)) {
+                if (kind !== InstructionKind.Reassign) {
+                    state.declared.add(place.identifier.declarationId);
+                }
+            }
+        }
+        return result;
     }
 };
 function transformDestructuring(state, instr, destructure) {
@@ -39368,9 +39427,12 @@ function transformDestructuring(state, instr, destructure) {
         if (isDeclared) {
             reassigned.add(place.identifier.id);
         }
-        hasDeclaration || (hasDeclaration = !isDeclared);
+        else {
+            hasDeclaration = true;
+        }
     }
-    if (reassigned.size === 0 || !hasDeclaration) {
+    if (!hasDeclaration) {
+        destructure.lvalue.kind = InstructionKind.Reassign;
         return null;
     }
     const instructions = [];
@@ -41052,6 +41114,7 @@ function applyEffect(context, state, _effect, initialized, effects) {
                 case ValueKind.Primitive: {
                     break;
                 }
+                case ValueKind.MaybeFrozen:
                 case ValueKind.Frozen: {
                     sourceType = 'frozen';
                     break;
@@ -44792,6 +44855,85 @@ function findOptionalPlaces(fn) {
     return optionals;
 }
 
+function createControlDominators(fn, isControlVariable) {
+    const postDominators = computePostDominatorTree(fn, {
+        includeThrowsAsExitNode: false,
+    });
+    const postDominatorFrontierCache = new Map();
+    function isControlledBlock(id) {
+        let controlBlocks = postDominatorFrontierCache.get(id);
+        if (controlBlocks === undefined) {
+            controlBlocks = postDominatorFrontier(fn, postDominators, id);
+            postDominatorFrontierCache.set(id, controlBlocks);
+        }
+        for (const blockId of controlBlocks) {
+            const controlBlock = fn.body.blocks.get(blockId);
+            switch (controlBlock.terminal.kind) {
+                case 'if':
+                case 'branch': {
+                    if (isControlVariable(controlBlock.terminal.test)) {
+                        return true;
+                    }
+                    break;
+                }
+                case 'switch': {
+                    if (isControlVariable(controlBlock.terminal.test)) {
+                        return true;
+                    }
+                    for (const case_ of controlBlock.terminal.cases) {
+                        if (case_.test !== null && isControlVariable(case_.test)) {
+                            return true;
+                        }
+                    }
+                    break;
+                }
+            }
+        }
+        return false;
+    }
+    return isControlledBlock;
+}
+function postDominatorFrontier(fn, postDominators, targetId) {
+    const visited = new Set();
+    const frontier = new Set();
+    const targetPostDominators = postDominatorsOf(fn, postDominators, targetId);
+    for (const blockId of [...targetPostDominators, targetId]) {
+        if (visited.has(blockId)) {
+            continue;
+        }
+        visited.add(blockId);
+        const block = fn.body.blocks.get(blockId);
+        for (const pred of block.preds) {
+            if (!targetPostDominators.has(pred)) {
+                frontier.add(pred);
+            }
+        }
+    }
+    return frontier;
+}
+function postDominatorsOf(fn, postDominators, targetId) {
+    var _a;
+    const result = new Set();
+    const visited = new Set();
+    const queue = [targetId];
+    while (queue.length) {
+        const currentId = queue.shift();
+        if (visited.has(currentId)) {
+            continue;
+        }
+        visited.add(currentId);
+        const current = fn.body.blocks.get(currentId);
+        for (const pred of current.preds) {
+            const predPostDominator = (_a = postDominators.get(pred)) !== null && _a !== void 0 ? _a : pred;
+            if (predPostDominator === targetId || result.has(predPostDominator)) {
+                result.add(pred);
+            }
+            queue.push(pred);
+        }
+    }
+    return result;
+}
+
 class StableSidemap {
     constructor(env) {
         this.map = new Map();
@@ -44867,42 +45009,7 @@ function inferReactivePlaces(fn) {
         const place = param.kind === 'Identifier' ? param : param.place;
         reactiveIdentifiers.markReactive(place);
     }
-    const postDominators = computePostDominatorTree(fn, {
-        includeThrowsAsExitNode: false,
-    });
-    const postDominatorFrontierCache = new Map();
-    function isReactiveControlledBlock(id) {
-        let controlBlocks = postDominatorFrontierCache.get(id);
-        if (controlBlocks === undefined) {
-            controlBlocks = postDominatorFrontier(fn, postDominators, id);
-            postDominatorFrontierCache.set(id, controlBlocks);
-        }
-        for (const blockId of controlBlocks) {
-            const controlBlock = fn.body.blocks.get(blockId);
-            switch (controlBlock.terminal.kind) {
-                case 'if':
-                case 'branch': {
-                    if (reactiveIdentifiers.isReactive(controlBlock.terminal.test)) {
-                        return true;
-                    }
-                    break;
-                }
-                case 'switch': {
-                    if (reactiveIdentifiers.isReactive(controlBlock.terminal.test)) {
-                        return true;
-                    }
-                    for (const case_ of controlBlock.terminal.cases) {
-                        if (case_.test !== null &&
-                            reactiveIdentifiers.isReactive(case_.test)) {
-                            return true;
-                        }
-                    }
-                    break;
-                }
-            }
-        }
-        return false;
-    }
+    const isReactiveControlledBlock = createControlDominators(fn, place => reactiveIdentifiers.isReactive(place));
     do {
         for (const [, block] of fn.body.blocks) {
             let hasReactiveControl = isReactiveControlledBlock(block.id);
@@ -45020,46 +45127,6 @@ function inferReactivePlaces(fn) {
     }
     propagateReactivityToInnerFunctions(fn, true);
 }
-function postDominatorFrontier(fn, postDominators, targetId) {
-    const visited = new Set();
-    const frontier = new Set();
-    const targetPostDominators = postDominatorsOf(fn, postDominators, targetId);
-    for (const blockId of [...targetPostDominators, targetId]) {
-        if (visited.has(blockId)) {
-            continue;
-        }
-        visited.add(blockId);
-        const block = fn.body.blocks.get(blockId);
-        for (const pred of block.preds) {
-            if (!targetPostDominators.has(pred)) {
-                frontier.add(pred);
-            }
-        }
-    }
-    return frontier;
-}
-function postDominatorsOf(fn, postDominators, targetId) {
-    var _a;
-    const result = new Set();
-    const visited = new Set();
-    const queue = [targetId];
-    while (queue.length) {
-        const currentId = queue.shift();
-        if (visited.has(currentId)) {
-            continue;
-        }
-        visited.add(currentId);
-        const current = fn.body.blocks.get(currentId);
-        for (const pred of current.preds) {
-            const predPostDominator = (_a = postDominators.get(pred)) !== null && _a !== void 0 ? _a : pred;
-            if (predPostDominator === targetId || result.has(predPostDominator)) {
-                result.add(pred);
-            }
-            queue.push(pred);
-        }
-    }
-    return result;
-}
 class ReactivityMap {
     constructor(aliasedIdentifiers) {
         this.hasChanges = false;
@@ -48306,6 +48373,25 @@ function* generateInstructionTypes(env, names, instr) {
                     }
                 }
             }
+            if (env.config.enableInferEventHandlers) {
+                if (value.kind === 'JsxExpression' &&
+                    value.tag.kind === 'BuiltinTag' &&
+                    !value.tag.name.includes('-')) {
+                    for (const prop of value.props) {
+                        if (prop.kind === 'JsxAttribute' &&
+                            prop.name.startsWith('on') &&
+                            prop.name.length > 2 &&
+                            prop.name[2] === prop.name[2].toUpperCase()) {
+                            yield equation(prop.place.identifier.type, {
+                                kind: 'Function',
+                                shapeId: BuiltInEventHandlerId,
+                                return: makeType(),
+                                isConstructor: false,
+                            });
+                        }
+                    }
+                }
+            }
             yield equation(left, { kind: 'Object', shapeId: BuiltInJsxId });
             break;
         }
@@ -49229,6 +49315,10 @@ function refTypeOfType(place) {
         return { kind: 'None' };
     }
 }
+function isEventHandlerType(identifier) {
+    const type = identifier.type;
+    return type.kind === 'Function' && type.shapeId === BuiltInEventHandlerId;
+}
 function tyEqual(a, b) {
     if (a.kind !== b.kind) {
         return false;
@@ -49515,8 +49605,10 @@ function validateNoRefAccessInRenderImpl(fn, env) {
                         }
                         if (!didError) {
                             const isRefLValue = isUseRefType(instr.lvalue.identifier);
+                            const isEventHandlerLValue = isEventHandlerType(instr.lvalue.identifier);
                             for (const operand of eachInstructionValueOperand(instr.value)) {
                                 if (isRefLValue ||
+                                    isEventHandlerLValue ||
                                     (hookKind != null &&
                                         hookKind !== 'useState' &&
                                         hookKind !== 'useReducer')) {
@@ -51015,20 +51107,84 @@ function validateNoSetStateInEffects(fn, env) {
     return errors.asResult();
 }
 function getSetStateCall(fn, setStateFunctions, env) {
+    const enableAllowSetStateFromRefsInEffects = env.config.enableAllowSetStateFromRefsInEffects;
     const refDerivedValues = new Set();
     const isDerivedFromRef = (place) => {
         return (refDerivedValues.has(place.identifier.id) ||
             isUseRefType(place.identifier) ||
             isRefValueType(place.identifier));
     };
+    const isRefControlledBlock = enableAllowSetStateFromRefsInEffects
+        ? createControlDominators(fn, place => isDerivedFromRef(place))
+        : () => false;
     for (const [, block] of fn.body.blocks) {
+        if (enableAllowSetStateFromRefsInEffects) {
+            for (const phi of block.phis) {
+                if (isDerivedFromRef(phi.place)) {
+                    continue;
+                }
+                let isPhiDerivedFromRef = false;
+                for (const [, operand] of phi.operands) {
+                    if (isDerivedFromRef(operand)) {
+                        isPhiDerivedFromRef = true;
+                        break;
+                    }
+                }
+                if (isPhiDerivedFromRef) {
+                    refDerivedValues.add(phi.place.identifier.id);
+                }
+                else {
+                    for (const [pred] of phi.operands) {
+                        if (isRefControlledBlock(pred)) {
+                            refDerivedValues.add(phi.place.identifier.id);
+                            break;
+                        }
+                    }
+                }
+            }
+        }
         for (const instr of block.instructions) {
-            if (env.config.enableAllowSetStateFromRefsInEffects) {
+            if (enableAllowSetStateFromRefsInEffects) {
                 const hasRefOperand = Iterable_some(eachInstructionValueOperand(instr.value), isDerivedFromRef);
                 if (hasRefOperand) {
                     for (const lvalue of eachInstructionLValue(instr)) {
                         refDerivedValues.add(lvalue.identifier.id);
                     }
+                    for (const operand of eachInstructionValueOperand(instr.value)) {
+                        switch (operand.effect) {
+                            case Effect.Capture:
+                            case Effect.Store:
+                            case Effect.ConditionallyMutate:
+                            case Effect.ConditionallyMutateIterator:
+                            case Effect.Mutate: {
+                                if (isMutable(instr, operand)) {
+                                    refDerivedValues.add(operand.identifier.id);
+                                }
+                                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: null,
+                                        },
+                                    ],
+                                    suggestions: null,
+                                });
+                            }
+                            default: {
+                                assertExhaustive$1(operand.effect, `Unexpected effect kind \`${operand.effect}\``);
+                            }
+                        }
+                    }
                 }
                 if (instr.value.kind === 'PropertyLoad' &&
                     instr.value.property === 'current' &&
@@ -51055,13 +51211,16 @@ function getSetStateCall(fn, setStateFunctions, env) {
                     const callee = instr.value.callee;
                     if (isSetStateType(callee.identifier) ||
                         setStateFunctions.has(callee.identifier.id)) {
-                        if (env.config.enableAllowSetStateFromRefsInEffects) {
+                        if (enableAllowSetStateFromRefsInEffects) {
                             const arg = instr.value.args.at(0);
                             if (arg !== undefined &&
                                 arg.kind === 'Identifier' &&
                                 refDerivedValues.has(arg.identifier.id)) {
                                 return null;
                             }
+                            else if (isRefControlledBlock(block.id)) {
+                                continue;
+                            }
                         }
                         return callee;
                     }

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

@@ -18948,9 +18948,18 @@ function isRefOrRefLikeMutableType(type) {
 function isSetStateType(id) {
     return id.type.kind === 'Function' && id.type.shapeId === 'BuiltInSetState';
 }
+function isUseActionStateType(id) {
+    return (id.type.kind === 'Object' && id.type.shapeId === 'BuiltInUseActionState');
+}
 function isStartTransitionType(id) {
     return (id.type.kind === 'Function' && id.type.shapeId === 'BuiltInStartTransition');
 }
+function isUseOptimisticType(id) {
+    return (id.type.kind === 'Object' && id.type.shapeId === 'BuiltInUseOptimistic');
+}
+function isSetOptimisticType(id) {
+    return (id.type.kind === 'Function' && id.type.shapeId === 'BuiltInSetOptimistic');
+}
 function isSetActionStateType(id) {
     return (id.type.kind === 'Function' && id.type.shapeId === 'BuiltInSetActionState');
 }
@@ -18972,7 +18981,8 @@ function isStableType(id) {
         isSetActionStateType(id) ||
         isDispatcherType(id) ||
         isUseRefType(id) ||
-        isStartTransitionType(id));
+        isStartTransitionType(id) ||
+        isSetOptimisticType(id));
 }
 function isStableTypeContainer(id) {
     const type_ = id.type;
@@ -18980,8 +18990,9 @@ function isStableTypeContainer(id) {
         return false;
     }
     return (isUseStateType(id) ||
-        type_.shapeId === 'BuiltInUseActionState' ||
+        isUseActionStateType(id) ||
         isUseReducerType(id) ||
+        isUseOptimisticType(id) ||
         type_.shapeId === 'BuiltInUseTransition');
 }
 function evaluatesToStableTypeOrContainer(env, { value }) {
@@ -18994,6 +19005,7 @@ function evaluatesToStableTypeOrContainer(env, { value }) {
             case 'useActionState':
             case 'useRef':
             case 'useTransition':
+            case 'useOptimistic':
                 return true;
         }
     }
@@ -19842,6 +19854,29 @@ function* eachInstructionLValue(instr) {
     }
     yield* eachInstructionValueLValue(instr.value);
 }
+function* eachInstructionLValueWithKind(instr) {
+    switch (instr.value.kind) {
+        case 'DeclareContext':
+        case 'StoreContext':
+        case 'DeclareLocal':
+        case 'StoreLocal': {
+            yield [instr.value.lvalue.place, instr.value.lvalue.kind];
+            break;
+        }
+        case 'Destructure': {
+            const kind = instr.value.lvalue.kind;
+            for (const place of eachPatternOperand(instr.value.lvalue.pattern)) {
+                yield [place, kind];
+            }
+            break;
+        }
+        case 'PostfixUpdate':
+        case 'PrefixUpdate': {
+            yield [instr.value.lvalue, InstructionKind.Reassign];
+            break;
+        }
+    }
+}
 function* eachInstructionValueLValue(value) {
     switch (value.kind) {
         case 'DeclareContext':
@@ -22072,12 +22107,15 @@ const BuiltInUseReducerId = 'BuiltInUseReducer';
 const BuiltInDispatchId = 'BuiltInDispatch';
 const BuiltInUseContextHookId = 'BuiltInUseContextHook';
 const BuiltInUseTransitionId = 'BuiltInUseTransition';
+const BuiltInUseOptimisticId = 'BuiltInUseOptimistic';
+const BuiltInSetOptimisticId = 'BuiltInSetOptimistic';
 const BuiltInStartTransitionId = 'BuiltInStartTransition';
 const BuiltInFireId = 'BuiltInFire';
 const BuiltInFireFunctionId = 'BuiltInFireFunction';
 const BuiltInUseEffectEventId = 'BuiltInUseEffectEvent';
-const BuiltinEffectEventId = 'BuiltInEffectEventFunction';
+const BuiltInEffectEventId = 'BuiltInEffectEventFunction';
 const BuiltInAutodepsId = 'BuiltInAutoDepsId';
+const BuiltInEventHandlerId = 'BuiltInEventHandlerId';
 const ReanimatedSharedValueId = 'ReanimatedSharedValueId';
 const BUILTIN_SHAPES = new Map();
 addObject(BUILTIN_SHAPES, BuiltInPropsId, [
@@ -22685,6 +22723,19 @@ addObject(BUILTIN_SHAPES, BuiltInUseTransitionId, [
         }, BuiltInStartTransitionId),
     ],
 ]);
+addObject(BUILTIN_SHAPES, BuiltInUseOptimisticId, [
+    ['0', { kind: 'Poly' }],
+    [
+        '1',
+        addFunction(BUILTIN_SHAPES, [], {
+            positionalParams: [],
+            restParam: Effect.Freeze,
+            returnType: PRIMITIVE_TYPE,
+            calleeEffect: Effect.Read,
+            returnValueKind: ValueKind.Primitive,
+        }, BuiltInSetOptimisticId),
+    ],
+]);
 addObject(BUILTIN_SHAPES, BuiltInUseActionStateId, [
     ['0', { kind: 'Poly' }],
     [
@@ -22724,7 +22775,14 @@ addFunction(BUILTIN_SHAPES, [], {
     returnType: { kind: 'Poly' },
     calleeEffect: Effect.ConditionallyMutate,
     returnValueKind: ValueKind.Mutable,
-}, BuiltinEffectEventId);
+}, BuiltInEffectEventId);
+addFunction(BUILTIN_SHAPES, [], {
+    positionalParams: [],
+    restParam: Effect.ConditionallyMutate,
+    returnType: { kind: 'Poly' },
+    calleeEffect: Effect.ConditionallyMutate,
+    returnValueKind: ValueKind.Mutable,
+}, BuiltInEventHandlerId);
 addObject(BUILTIN_SHAPES, BuiltInMixedReadonlyId, [
     [
         'toString',
@@ -30915,6 +30973,18 @@ const REACT_APIS = [
             returnValueKind: ValueKind.Frozen,
         }),
     ],
+    [
+        'useOptimistic',
+        addHook(DEFAULT_SHAPES, {
+            positionalParams: [],
+            restParam: Effect.Freeze,
+            returnType: { kind: 'Object', shapeId: BuiltInUseOptimisticId },
+            calleeEffect: Effect.Read,
+            hookKind: 'useOptimistic',
+            returnValueKind: ValueKind.Frozen,
+            returnValueReason: ValueReason.State,
+        }),
+    ],
     [
         'use',
         addFunction(DEFAULT_SHAPES, [], {
@@ -30948,7 +31018,7 @@ const REACT_APIS = [
             returnType: {
                 kind: 'Function',
                 return: { kind: 'Poly' },
-                shapeId: BuiltinEffectEventId,
+                shapeId: BuiltInEffectEventId,
                 isConstructor: false,
             },
             calleeEffect: Effect.Read,
@@ -31971,6 +32041,7 @@ const EnvironmentConfigSchema = v4.z.object({
     validateNoVoidUseMemo: v4.z.boolean().default(true),
     validateNoDynamicallyCreatedComponentsOrHooks: v4.z.boolean().default(false),
     enableAllowSetStateFromRefsInEffects: v4.z.boolean().default(true),
+    enableInferEventHandlers: v4.z.boolean().default(false),
 });
 class Environment {
     constructor(scope, fnType, compilerMode, config, contextIdentifiers, parentFunction, logger, filename, code, programContext) {
@@ -37942,33 +38013,11 @@ function codegenInstructionNullable(cx, instr) {
         }
         else {
             lvalue = instr.value.lvalue.pattern;
-            let hasReassign = false;
-            let hasDeclaration = false;
             for (const place of eachPatternOperand(lvalue)) {
                 if (kind !== InstructionKind.Reassign &&
                     place.identifier.name === null) {
                     cx.temp.set(place.identifier.declarationId, null);
                 }
-                const isDeclared = cx.hasDeclared(place.identifier);
-                hasReassign || (hasReassign = isDeclared);
-                hasDeclaration || (hasDeclaration = !isDeclared);
-            }
-            if (hasReassign && hasDeclaration) {
-                CompilerError.invariant(false, {
-                    reason: 'Encountered a destructuring operation where some identifiers are already declared (reassignments) but others are not (declarations)',
-                    description: null,
-                    details: [
-                        {
-                            kind: 'error',
-                            loc: instr.loc,
-                            message: null,
-                        },
-                    ],
-                    suggestions: null,
-                });
-            }
-            else if (hasReassign) {
-                kind = InstructionKind.Reassign;
             }
             value = codegenPlaceToExpression(cx, instr.value.value);
         }
@@ -39172,10 +39221,13 @@ let Visitor$9 = class Visitor extends ReactiveFunctionTransform {
     }
     transformInstruction(instruction, state) {
         this.visitInstruction(instruction, state);
+        let instructionsToProcess = [instruction];
+        let result = { kind: 'keep' };
         if (instruction.value.kind === 'Destructure') {
             const transformed = transformDestructuring(state, instruction, instruction.value);
             if (transformed) {
-                return {
+                instructionsToProcess = transformed;
+                result = {
                     kind: 'replace-many',
                     value: transformed.map(instruction => ({
                         kind: 'instruction',
@@ -39184,7 +39236,14 @@ let Visitor$9 = class Visitor extends ReactiveFunctionTransform {
                 };
             }
         }
-        return { kind: 'keep' };
+        for (const instr of instructionsToProcess) {
+            for (const [place, kind] of eachInstructionLValueWithKind(instr)) {
+                if (kind !== InstructionKind.Reassign) {
+                    state.declared.add(place.identifier.declarationId);
+                }
+            }
+        }
+        return result;
     }
 };
 function transformDestructuring(state, instr, destructure) {
@@ -39195,9 +39254,12 @@ function transformDestructuring(state, instr, destructure) {
         if (isDeclared) {
             reassigned.add(place.identifier.id);
         }
-        hasDeclaration || (hasDeclaration = !isDeclared);
+        else {
+            hasDeclaration = true;
+        }
     }
-    if (reassigned.size === 0 || !hasDeclaration) {
+    if (!hasDeclaration) {
+        destructure.lvalue.kind = InstructionKind.Reassign;
         return null;
     }
     const instructions = [];
@@ -40879,6 +40941,7 @@ function applyEffect(context, state, _effect, initialized, effects) {
                 case ValueKind.Primitive: {
                     break;
                 }
+                case ValueKind.MaybeFrozen:
                 case ValueKind.Frozen: {
                     sourceType = 'frozen';
                     break;
@@ -44619,6 +44682,85 @@ function findOptionalPlaces(fn) {
     return optionals;
 }
 
+function createControlDominators(fn, isControlVariable) {
+    const postDominators = computePostDominatorTree(fn, {
+        includeThrowsAsExitNode: false,
+    });
+    const postDominatorFrontierCache = new Map();
+    function isControlledBlock(id) {
+        let controlBlocks = postDominatorFrontierCache.get(id);
+        if (controlBlocks === undefined) {
+            controlBlocks = postDominatorFrontier(fn, postDominators, id);
+            postDominatorFrontierCache.set(id, controlBlocks);
+        }
+        for (const blockId of controlBlocks) {
+            const controlBlock = fn.body.blocks.get(blockId);
+            switch (controlBlock.terminal.kind) {
+                case 'if':
+                case 'branch': {
+                    if (isControlVariable(controlBlock.terminal.test)) {
+                        return true;
+                    }
+                    break;
+                }
+                case 'switch': {
+                    if (isControlVariable(controlBlock.terminal.test)) {
+                        return true;
+                    }
+                    for (const case_ of controlBlock.terminal.cases) {
+                        if (case_.test !== null && isControlVariable(case_.test)) {
+                            return true;
+                        }
+                    }
+                    break;
+                }
+            }
+        }
+        return false;
+    }
+    return isControlledBlock;
+}
+function postDominatorFrontier(fn, postDominators, targetId) {
+    const visited = new Set();
+    const frontier = new Set();
+    const targetPostDominators = postDominatorsOf(fn, postDominators, targetId);
+    for (const blockId of [...targetPostDominators, targetId]) {
+        if (visited.has(blockId)) {
+            continue;
+        }
+        visited.add(blockId);
+        const block = fn.body.blocks.get(blockId);
+        for (const pred of block.preds) {
+            if (!targetPostDominators.has(pred)) {
+                frontier.add(pred);
+            }
+        }
+    }
+    return frontier;
+}
+function postDominatorsOf(fn, postDominators, targetId) {
+    var _a;
+    const result = new Set();
+    const visited = new Set();
+    const queue = [targetId];
+    while (queue.length) {
+        const currentId = queue.shift();
+        if (visited.has(currentId)) {
+            continue;
+        }
+        visited.add(currentId);
+        const current = fn.body.blocks.get(currentId);
+        for (const pred of current.preds) {
+            const predPostDominator = (_a = postDominators.get(pred)) !== null && _a !== void 0 ? _a : pred;
+            if (predPostDominator === targetId || result.has(predPostDominator)) {
+                result.add(pred);
+            }
+            queue.push(pred);
+        }
+    }
+    return result;
+}
+
 class StableSidemap {
     constructor(env) {
         this.map = new Map();
@@ -44694,42 +44836,7 @@ function inferReactivePlaces(fn) {
         const place = param.kind === 'Identifier' ? param : param.place;
         reactiveIdentifiers.markReactive(place);
     }
-    const postDominators = computePostDominatorTree(fn, {
-        includeThrowsAsExitNode: false,
-    });
-    const postDominatorFrontierCache = new Map();
-    function isReactiveControlledBlock(id) {
-        let controlBlocks = postDominatorFrontierCache.get(id);
-        if (controlBlocks === undefined) {
-            controlBlocks = postDominatorFrontier(fn, postDominators, id);
-            postDominatorFrontierCache.set(id, controlBlocks);
-        }
-        for (const blockId of controlBlocks) {
-            const controlBlock = fn.body.blocks.get(blockId);
-            switch (controlBlock.terminal.kind) {
-                case 'if':
-                case 'branch': {
-                    if (reactiveIdentifiers.isReactive(controlBlock.terminal.test)) {
-                        return true;
-                    }
-                    break;
-                }
-                case 'switch': {
-                    if (reactiveIdentifiers.isReactive(controlBlock.terminal.test)) {
-                        return true;
-                    }
-                    for (const case_ of controlBlock.terminal.cases) {
-                        if (case_.test !== null &&
-                            reactiveIdentifiers.isReactive(case_.test)) {
-                            return true;
-                        }
-                    }
-                    break;
-                }
-            }
-        }
-        return false;
-    }
+    const isReactiveControlledBlock = createControlDominators(fn, place => reactiveIdentifiers.isReactive(place));
     do {
         for (const [, block] of fn.body.blocks) {
             let hasReactiveControl = isReactiveControlledBlock(block.id);
@@ -44847,46 +44954,6 @@ function inferReactivePlaces(fn) {
     }
     propagateReactivityToInnerFunctions(fn, true);
 }
-function postDominatorFrontier(fn, postDominators, targetId) {
-    const visited = new Set();
-    const frontier = new Set();
-    const targetPostDominators = postDominatorsOf(fn, postDominators, targetId);
-    for (const blockId of [...targetPostDominators, targetId]) {
-        if (visited.has(blockId)) {
-            continue;
-        }
-        visited.add(blockId);
-        const block = fn.body.blocks.get(blockId);
-        for (const pred of block.preds) {
-            if (!targetPostDominators.has(pred)) {
-                frontier.add(pred);
-            }
-        }
-    }
-    return frontier;
-}
-function postDominatorsOf(fn, postDominators, targetId) {
-    var _a;
-    const result = new Set();
-    const visited = new Set();
-    const queue = [targetId];
-    while (queue.length) {
-        const currentId = queue.shift();
-        if (visited.has(currentId)) {
-            continue;
-        }
-        visited.add(currentId);
-        const current = fn.body.blocks.get(currentId);
-        for (const pred of current.preds) {
-            const predPostDominator = (_a = postDominators.get(pred)) !== null && _a !== void 0 ? _a : pred;
-            if (predPostDominator === targetId || result.has(predPostDominator)) {
-                result.add(pred);
-            }
-            queue.push(pred);
-        }
-    }
-    return result;
-}
 class ReactivityMap {
     constructor(aliasedIdentifiers) {
         this.hasChanges = false;
@@ -48133,6 +48200,25 @@ function* generateInstructionTypes(env, names, instr) {
                     }
                 }
             }
+            if (env.config.enableInferEventHandlers) {
+                if (value.kind === 'JsxExpression' &&
+                    value.tag.kind === 'BuiltinTag' &&
+                    !value.tag.name.includes('-')) {
+                    for (const prop of value.props) {
+                        if (prop.kind === 'JsxAttribute' &&
+                            prop.name.startsWith('on') &&
+                            prop.name.length > 2 &&
+                            prop.name[2] === prop.name[2].toUpperCase()) {
+                            yield equation(prop.place.identifier.type, {
+                                kind: 'Function',
+                                shapeId: BuiltInEventHandlerId,
+                                return: makeType(),
+                                isConstructor: false,
+                            });
+                        }
+                    }
+                }
+            }
             yield equation(left, { kind: 'Object', shapeId: BuiltInJsxId });
             break;
         }
@@ -49056,6 +49142,10 @@ function refTypeOfType(place) {
         return { kind: 'None' };
     }
 }
+function isEventHandlerType(identifier) {
+    const type = identifier.type;
+    return type.kind === 'Function' && type.shapeId === BuiltInEventHandlerId;
+}
 function tyEqual(a, b) {
     if (a.kind !== b.kind) {
         return false;
@@ -49342,8 +49432,10 @@ function validateNoRefAccessInRenderImpl(fn, env) {
                         }
                         if (!didError) {
                             const isRefLValue = isUseRefType(instr.lvalue.identifier);
+                            const isEventHandlerLValue = isEventHandlerType(instr.lvalue.identifier);
                             for (const operand of eachInstructionValueOperand(instr.value)) {
                                 if (isRefLValue ||
+                                    isEventHandlerLValue ||
                                     (hookKind != null &&
                                         hookKind !== 'useState' &&
                                         hookKind !== 'useReducer')) {
@@ -50842,20 +50934,84 @@ function validateNoSetStateInEffects(fn, env) {
     return errors.asResult();
 }
 function getSetStateCall(fn, setStateFunctions, env) {
+    const enableAllowSetStateFromRefsInEffects = env.config.enableAllowSetStateFromRefsInEffects;
     const refDerivedValues = new Set();
     const isDerivedFromRef = (place) => {
         return (refDerivedValues.has(place.identifier.id) ||
             isUseRefType(place.identifier) ||
             isRefValueType(place.identifier));
     };
+    const isRefControlledBlock = enableAllowSetStateFromRefsInEffects
+        ? createControlDominators(fn, place => isDerivedFromRef(place))
+        : () => false;
     for (const [, block] of fn.body.blocks) {
+        if (enableAllowSetStateFromRefsInEffects) {
+            for (const phi of block.phis) {
+                if (isDerivedFromRef(phi.place)) {
+                    continue;
+                }
+                let isPhiDerivedFromRef = false;
+                for (const [, operand] of phi.operands) {
+                    if (isDerivedFromRef(operand)) {
+                        isPhiDerivedFromRef = true;
+                        break;
+                    }
+                }
+                if (isPhiDerivedFromRef) {
+                    refDerivedValues.add(phi.place.identifier.id);
+                }
+                else {
+                    for (const [pred] of phi.operands) {
+                        if (isRefControlledBlock(pred)) {
+                            refDerivedValues.add(phi.place.identifier.id);
+                            break;
+                        }
+                    }
+                }
+            }
+        }
         for (const instr of block.instructions) {
-            if (env.config.enableAllowSetStateFromRefsInEffects) {
+            if (enableAllowSetStateFromRefsInEffects) {
                 const hasRefOperand = Iterable_some(eachInstructionValueOperand(instr.value), isDerivedFromRef);
                 if (hasRefOperand) {
                     for (const lvalue of eachInstructionLValue(instr)) {
                         refDerivedValues.add(lvalue.identifier.id);
                     }
+                    for (const operand of eachInstructionValueOperand(instr.value)) {
+                        switch (operand.effect) {
+                            case Effect.Capture:
+                            case Effect.Store:
+                            case Effect.ConditionallyMutate:
+                            case Effect.ConditionallyMutateIterator:
+                            case Effect.Mutate: {
+                                if (isMutable(instr, operand)) {
+                                    refDerivedValues.add(operand.identifier.id);
+                                }
+                                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: null,
+                                        },
+                                    ],
+                                    suggestions: null,
+                                });
+                            }
+                            default: {
+                                assertExhaustive$1(operand.effect, `Unexpected effect kind \`${operand.effect}\``);
+                            }
+                        }
+                    }
                 }
                 if (instr.value.kind === 'PropertyLoad' &&
                     instr.value.property === 'current' &&
@@ -50882,13 +51038,16 @@ function getSetStateCall(fn, setStateFunctions, env) {
                     const callee = instr.value.callee;
                     if (isSetStateType(callee.identifier) ||
                         setStateFunctions.has(callee.identifier.id)) {
-                        if (env.config.enableAllowSetStateFromRefsInEffects) {
+                        if (enableAllowSetStateFromRefsInEffects) {
                             const arg = instr.value.args.at(0);
                             if (arg !== undefined &&
                                 arg.kind === 'Identifier' &&
                                 refDerivedValues.has(arg.identifier.id)) {
                                 return null;
                             }
+                            else if (isRefControlledBlock(block.id)) {
+                                continue;
+                            }
                         }
                         return callee;
                     }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "eslint-plugin-react-hooks",
   "description": "ESLint rules for React Hooks",
-  "version": "7.1.0-canary-257b033f-20251113",
+  "version": "7.1.0-canary-0972e239-20251118",
   "repository": {
     "type": "git",
     "url": "https://github.com/facebook/react.git",