babel-plugin-react-compiler 0.0.0-experimental-22c6e49-20241220 → 0.0.0-experimental-b2e8e9c-20241220

package/dist/index.js

@@ -127070,6 +127070,13 @@ function printSourceLocation(loc) {
     return `${loc.start.line}:${loc.start.column}:${loc.end.line}:${loc.end.column}`;
   }
 }
+function printSourceLocationLine(loc) {
+  if (typeof loc === 'symbol') {
+    return 'generated';
+  } else {
+    return `${loc.start.line}:${loc.end.line}`;
+  }
+}
 function getFunctionName$1(instrValue, defaultValue) {
   var _a;
   switch (instrValue.kind) {
@@ -136948,6 +136955,7 @@ class Environment {
       'f'
     );
     this.hasLoweredContextAccess = false;
+    this.hasFireRewrite = false;
     if (
       config.disableMemoizationForDebugging &&
       config.enableChangeDetectionForDebugging != null
@@ -141031,7 +141039,7 @@ var _Context_nextScheduleId,
   _Context_catchHandlers,
   _Context_controlFlowStack;
 function buildReactiveFunction(fn) {
-  const cx = new Context$2(fn.body);
+  const cx = new Context$3(fn.body);
   const driver = new Driver(cx);
   const body = driver.traverseBlock(cx.block(fn.body.entry));
   return {
@@ -142079,7 +142087,7 @@ class Driver {
     };
   }
 }
-let Context$2 = class Context {
+let Context$3 = class Context {
   constructor(ir) {
     _Context_nextScheduleId.set(this, 0);
     this.emitted = new Set();
@@ -142467,7 +142475,7 @@ function codegenFunction(
   {uniqueIdentifiers: uniqueIdentifiers, fbtOperands: fbtOperands}
 ) {
   var _a, _b, _c;
-  const cx = new Context$1(
+  const cx = new Context$2(
     fn.env,
     (_a = fn.id) !== null && _a !== void 0 ? _a : '[[ anonymous ]]',
     uniqueIdentifiers,
@@ -142632,7 +142640,7 @@ function codegenFunction(
     pruneHoistedContexts(reactiveFunction);
     const identifiers = renameVariables(reactiveFunction);
     const codegen = codegenReactiveFunction(
-      new Context$1(
+      new Context$2(
         cx.env,
         (_c = reactiveFunction.id) !== null && _c !== void 0
           ? _c
@@ -142690,6 +142698,7 @@ function codegenReactiveFunction(cx, fn) {
     prunedMemoValues: countMemoBlockVisitor.prunedMemoValues,
     outlined: [],
     hasLoweredContextAccess: fn.env.hasLoweredContextAccess,
+    hasFireRewrite: fn.env.hasFireRewrite,
   });
 }
 class CountMemoBlockVisitor extends ReactiveFunctionVisitor {
@@ -142719,7 +142728,7 @@ function convertParameter(param) {
     return t__namespace.restElement(convertIdentifier(param.place.identifier));
   }
 }
-let Context$1 = class Context {
+let Context$2 = class Context {
   constructor(env, fnName, uniqueIdentifiers, fbtOperands, temporaries = null) {
     _Context_nextCacheIndex.set(this, 0);
     _Context_declarations$1.set(this, new Set());
@@ -144054,7 +144063,7 @@ function codegenInstructionValue(cx, instrValue) {
               pruneUnusedLabels(reactiveFunction);
               pruneUnusedLValues(reactiveFunction);
               const fn = codegenReactiveFunction(
-                new Context$1(
+                new Context$2(
                   cx.env,
                   (_e = reactiveFunction.id) !== null && _e !== void 0
                     ? _e
@@ -144253,7 +144262,7 @@ function codegenInstructionValue(cx, instrValue) {
       pruneUnusedLValues(reactiveFunction);
       pruneHoistedContexts(reactiveFunction);
       const fn = codegenReactiveFunction(
-        new Context$1(
+        new Context$2(
           cx.env,
           (_g = reactiveFunction.id) !== null && _g !== void 0
             ? _g
@@ -152307,7 +152316,7 @@ function joinRefAccessTypes(...types) {
   );
 }
 function validateNoRefAccessInRenderImpl(fn, env) {
-  var _a, _b, _c, _d, _e, _f, _g, _h;
+  var _a, _b, _c, _d, _e, _f, _g, _h, _j;
   let returnValues = [];
   let place;
   for (const param of fn.params) {
@@ -152380,31 +152389,41 @@ function validateNoRefAccessInRenderImpl(fn, env) {
             );
             break;
           }
-          case 'LoadContext':
-          case 'LoadLocal': {
+          case 'TypeCastExpression': {
             env.set(
               instr.lvalue.identifier.id,
-              (_a = env.get(instr.value.place.identifier.id)) !== null &&
+              (_a = env.get(instr.value.value.identifier.id)) !== null &&
                 _a !== void 0
                 ? _a
                 : refTypeOfType(instr.lvalue)
             );
             break;
           }
-          case 'StoreContext':
-          case 'StoreLocal': {
+          case 'LoadContext':
+          case 'LoadLocal': {
             env.set(
-              instr.value.lvalue.place.identifier.id,
-              (_b = env.get(instr.value.value.identifier.id)) !== null &&
+              instr.lvalue.identifier.id,
+              (_b = env.get(instr.value.place.identifier.id)) !== null &&
                 _b !== void 0
                 ? _b
-                : refTypeOfType(instr.value.lvalue.place)
+                : refTypeOfType(instr.lvalue)
             );
+            break;
+          }
+          case 'StoreContext':
+          case 'StoreLocal': {
             env.set(
-              instr.lvalue.identifier.id,
+              instr.value.lvalue.place.identifier.id,
               (_c = env.get(instr.value.value.identifier.id)) !== null &&
                 _c !== void 0
                 ? _c
+                : refTypeOfType(instr.value.lvalue.place)
+            );
+            env.set(
+              instr.lvalue.identifier.id,
+              (_d = env.get(instr.value.value.identifier.id)) !== null &&
+                _d !== void 0
+                ? _d
                 : refTypeOfType(instr.lvalue)
             );
             break;
@@ -152501,8 +152520,8 @@ function validateNoRefAccessInRenderImpl(fn, env) {
             for (const operand of eachInstructionValueOperand(instr.value)) {
               validateNoDirectRefValueAccess(errors, operand, env);
               types.push(
-                (_d = env.get(operand.identifier.id)) !== null && _d !== void 0
-                  ? _d
+                (_e = env.get(operand.identifier.id)) !== null && _e !== void 0
+                  ? _e
                   : {kind: 'None'}
               );
             }
@@ -152609,16 +152628,16 @@ function validateNoRefAccessInRenderImpl(fn, env) {
         }
         if (
           isUseRefType(instr.lvalue.identifier) &&
-          ((_e = env.get(instr.lvalue.identifier.id)) === null || _e === void 0
+          ((_f = env.get(instr.lvalue.identifier.id)) === null || _f === void 0
             ? void 0
-            : _e.kind) !== 'Ref'
+            : _f.kind) !== 'Ref'
         ) {
           env.set(
             instr.lvalue.identifier.id,
             joinRefAccessTypes(
-              (_f = env.get(instr.lvalue.identifier.id)) !== null &&
-                _f !== void 0
-                ? _f
+              (_g = env.get(instr.lvalue.identifier.id)) !== null &&
+                _g !== void 0
+                ? _g
                 : {kind: 'None'},
               {kind: 'Ref', refId: nextRefId()}
             )
@@ -152626,16 +152645,16 @@ function validateNoRefAccessInRenderImpl(fn, env) {
         }
         if (
           isRefValueType(instr.lvalue.identifier) &&
-          ((_g = env.get(instr.lvalue.identifier.id)) === null || _g === void 0
+          ((_h = env.get(instr.lvalue.identifier.id)) === null || _h === void 0
             ? void 0
-            : _g.kind) !== 'RefValue'
+            : _h.kind) !== 'RefValue'
         ) {
           env.set(
             instr.lvalue.identifier.id,
             joinRefAccessTypes(
-              (_h = env.get(instr.lvalue.identifier.id)) !== null &&
-                _h !== void 0
-                ? _h
+              (_j = env.get(instr.lvalue.identifier.id)) !== null &&
+                _j !== void 0
+                ? _j
                 : {kind: 'None'},
               {kind: 'RefValue', loc: instr.loc}
             )
@@ -155008,7 +155027,7 @@ function getProperty(object, propertyName, optional, temporaries) {
   }
   return property;
 }
-class Context {
+let Context$1 = class Context {
   constructor(
     temporariesUsedOutsideScope,
     temporaries,
@@ -155248,7 +155267,7 @@ class Context {
         ))
     );
   }
-}
+};
 (_Context_declarations = new WeakMap()),
   (_Context_reassignments = new WeakMap()),
   (_Context_scopes = new WeakMap()),
@@ -155341,7 +155360,7 @@ function collectDependencies(
   temporaries,
   processedInstrsInOptional
 ) {
-  const context = new Context(
+  const context = new Context$1(
     usedOutsideDeclaringScope,
     temporaries,
     processedInstrsInOptional
@@ -155796,6 +155815,622 @@ function optimizePropsMethodCalls(fn) {
     }
   }
 }
+var _Context_env,
+  _Context_errors,
+  _Context_callExpressions,
+  _Context_functionExpressions,
+  _Context_loadLocals,
+  _Context_fireCalleesToFireFunctions,
+  _Context_calleesWithInsertedFire,
+  _Context_capturedCalleeIdentifierIds,
+  _Context_inUseEffectLambda,
+  _Context_loadGlobalInstructionIds,
+  _Context_arrayExpressions;
+const CANNOT_COMPILE_FIRE = 'Cannot compile `fire`';
+function transformFire(fn) {
+  const context = new Context(fn.env);
+  replaceFireFunctions(fn, context);
+  if (!context.hasErrors()) {
+    ensureNoMoreFireUses(fn, context);
+  }
+  context.throwIfErrorsFound();
+}
+function replaceFireFunctions(fn, context) {
+  let hasRewrite = false;
+  for (const [, block] of fn.body.blocks) {
+    const rewriteInstrs = new Map();
+    const deleteInstrs = new Set();
+    for (const instr of block.instructions) {
+      const {value: value, lvalue: lvalue} = instr;
+      if (
+        value.kind === 'CallExpression' &&
+        isUseEffectHookType(value.callee.identifier) &&
+        value.args.length > 0 &&
+        value.args[0].kind === 'Identifier'
+      ) {
+        const lambda = context.getFunctionExpression(
+          value.args[0].identifier.id
+        );
+        if (lambda != null) {
+          const capturedCallees =
+            visitFunctionExpressionAndPropagateFireDependencies(
+              lambda,
+              context,
+              true
+            );
+          const newInstrs = [];
+          for (const [
+            fireCalleePlace,
+            fireCalleeInfo,
+          ] of capturedCallees.entries()) {
+            if (!context.hasCalleeWithInsertedFire(fireCalleePlace)) {
+              context.addCalleeWithInsertedFire(fireCalleePlace);
+              const loadUseFireInstr = makeLoadUseFireInstruction(fn.env);
+              const loadFireCalleeInstr = makeLoadFireCalleeInstruction(
+                fn.env,
+                fireCalleeInfo.capturedCalleeIdentifier
+              );
+              const callUseFireInstr = makeCallUseFireInstruction(
+                fn.env,
+                loadUseFireInstr.lvalue,
+                loadFireCalleeInstr.lvalue
+              );
+              const storeUseFireInstr = makeStoreUseFireInstruction(
+                fn.env,
+                callUseFireInstr.lvalue,
+                fireCalleeInfo.fireFunctionBinding
+              );
+              newInstrs.push(
+                loadUseFireInstr,
+                loadFireCalleeInstr,
+                callUseFireInstr,
+                storeUseFireInstr
+              );
+              const loadUseEffectInstrId = context.getLoadGlobalInstrId(
+                value.callee.identifier.id
+              );
+              if (loadUseEffectInstrId == null) {
+                context.pushError({
+                  loc: value.loc,
+                  description: null,
+                  severity: exports.ErrorSeverity.Invariant,
+                  reason: '[InsertFire] No LoadGlobal found for useEffect call',
+                  suggestions: null,
+                });
+                continue;
+              }
+              rewriteInstrs.set(loadUseEffectInstrId, newInstrs);
+            }
+          }
+          ensureNoRemainingCalleeCaptures(
+            lambda.loweredFunc.func,
+            context,
+            capturedCallees
+          );
+          if (
+            value.args.length > 1 &&
+            value.args[1] != null &&
+            value.args[1].kind === 'Identifier'
+          ) {
+            const depArray = value.args[1];
+            const depArrayExpression = context.getArrayExpression(
+              depArray.identifier.id
+            );
+            if (depArrayExpression != null) {
+              for (const dependency of depArrayExpression.elements) {
+                if (dependency.kind === 'Identifier') {
+                  const loadOfDependency = context.getLoadLocalInstr(
+                    dependency.identifier.id
+                  );
+                  if (loadOfDependency != null) {
+                    const replacedDepArrayItem = capturedCallees.get(
+                      loadOfDependency.place.identifier.id
+                    );
+                    if (replacedDepArrayItem != null) {
+                      loadOfDependency.place =
+                        replacedDepArrayItem.fireFunctionBinding;
+                    }
+                  }
+                }
+              }
+            } else {
+              context.pushError({
+                loc: value.args[1].loc,
+                description:
+                  'You must use an array literal for an effect dependency array when that effect uses `fire()`',
+                severity: exports.ErrorSeverity.Invariant,
+                reason: CANNOT_COMPILE_FIRE,
+                suggestions: null,
+              });
+            }
+          } else if (value.args.length > 1 && value.args[1].kind === 'Spread') {
+            context.pushError({
+              loc: value.args[1].place.loc,
+              description:
+                'You must use an array literal for an effect dependency array when that effect uses `fire()`',
+              severity: exports.ErrorSeverity.Invariant,
+              reason: CANNOT_COMPILE_FIRE,
+              suggestions: null,
+            });
+          }
+        }
+      } else if (
+        value.kind === 'CallExpression' &&
+        value.callee.identifier.type.kind === 'Function' &&
+        value.callee.identifier.type.shapeId === BuiltInFireId &&
+        context.inUseEffectLambda()
+      ) {
+        if (value.args.length === 1 && value.args[0].kind === 'Identifier') {
+          const callExpr = context.getCallExpression(
+            value.args[0].identifier.id
+          );
+          if (callExpr != null) {
+            const calleeId = callExpr.callee.identifier.id;
+            const loadLocal = context.getLoadLocalInstr(calleeId);
+            if (loadLocal == null) {
+              context.pushError({
+                loc: value.loc,
+                description: null,
+                severity: exports.ErrorSeverity.Invariant,
+                reason:
+                  '[InsertFire] No loadLocal found for fire call argument',
+                suggestions: null,
+              });
+              continue;
+            }
+            const fireFunctionBinding =
+              context.getOrGenerateFireFunctionBinding(
+                loadLocal.place,
+                value.loc
+              );
+            loadLocal.place = Object.assign({}, fireFunctionBinding);
+            deleteInstrs.add(instr.id);
+          } else {
+            context.pushError({
+              loc: value.loc,
+              description:
+                '`fire()` can only receive a function call such as `fire(fn(a,b)). Method calls and other expressions are not allowed',
+              severity: exports.ErrorSeverity.InvalidReact,
+              reason: CANNOT_COMPILE_FIRE,
+              suggestions: null,
+            });
+          }
+        } else {
+          let description =
+            'fire() can only take in a single call expression as an argument';
+          if (value.args.length === 0) {
+            description += ' but received none';
+          } else if (value.args.length > 1) {
+            description += ' but received multiple arguments';
+          } else if (value.args[0].kind === 'Spread') {
+            description += ' but received a spread argument';
+          }
+          context.pushError({
+            loc: value.loc,
+            description: description,
+            severity: exports.ErrorSeverity.InvalidReact,
+            reason: CANNOT_COMPILE_FIRE,
+            suggestions: null,
+          });
+        }
+      } else if (value.kind === 'CallExpression') {
+        context.addCallExpression(lvalue.identifier.id, value);
+      } else if (
+        value.kind === 'FunctionExpression' &&
+        context.inUseEffectLambda()
+      ) {
+        visitFunctionExpressionAndPropagateFireDependencies(
+          value,
+          context,
+          false
+        );
+      } else if (value.kind === 'FunctionExpression') {
+        context.addFunctionExpression(lvalue.identifier.id, value);
+      } else if (value.kind === 'LoadLocal') {
+        context.addLoadLocalInstr(lvalue.identifier.id, value);
+      } else if (
+        value.kind === 'LoadGlobal' &&
+        value.binding.kind === 'ImportSpecifier' &&
+        value.binding.module === 'react' &&
+        value.binding.imported === 'fire' &&
+        context.inUseEffectLambda()
+      ) {
+        deleteInstrs.add(instr.id);
+      } else if (value.kind === 'LoadGlobal') {
+        context.addLoadGlobalInstrId(lvalue.identifier.id, instr.id);
+      } else if (value.kind === 'ArrayExpression') {
+        context.addArrayExpression(lvalue.identifier.id, value);
+      }
+    }
+    block.instructions = rewriteInstructions(rewriteInstrs, block.instructions);
+    block.instructions = deleteInstructions(deleteInstrs, block.instructions);
+    if (rewriteInstrs.size > 0 || deleteInstrs.size > 0) {
+      hasRewrite = true;
+      fn.env.hasFireRewrite = true;
+    }
+  }
+  if (hasRewrite) {
+    markInstructionIds(fn.body);
+  }
+}
+function visitFunctionExpressionAndPropagateFireDependencies(
+  fnExpr,
+  context,
+  enteringUseEffect
+) {
+  let withScope = enteringUseEffect
+    ? context.withUseEffectLambdaScope.bind(context)
+    : context.withFunctionScope.bind(context);
+  const calleesCapturedByFnExpression = withScope(() =>
+    replaceFireFunctions(fnExpr.loweredFunc.func, context)
+  );
+  const loadLocalsToDepLoads = new Map();
+  for (const dep of fnExpr.loweredFunc.dependencies) {
+    const loadLocal = context.getLoadLocalInstr(dep.identifier.id);
+    if (loadLocal != null) {
+      loadLocalsToDepLoads.set(loadLocal.place.identifier.id, loadLocal);
+    }
+  }
+  const replacedCallees = new Map();
+  for (const [
+    calleeIdentifierId,
+    loadedFireFunctionBindingPlace,
+  ] of calleesCapturedByFnExpression.entries()) {
+    const loadLocal = loadLocalsToDepLoads.get(calleeIdentifierId);
+    if (loadLocal == null) {
+      context.pushError({
+        loc: fnExpr.loc,
+        description: null,
+        severity: exports.ErrorSeverity.Invariant,
+        reason:
+          '[InsertFire] No loadLocal found for fire call argument for lambda',
+        suggestions: null,
+      });
+      continue;
+    }
+    const oldPlaceId = loadLocal.place.identifier.id;
+    loadLocal.place = Object.assign(
+      {},
+      loadedFireFunctionBindingPlace.fireFunctionBinding
+    );
+    replacedCallees.set(
+      oldPlaceId,
+      loadedFireFunctionBindingPlace.fireFunctionBinding
+    );
+  }
+  for (
+    let contextIdx = 0;
+    contextIdx < fnExpr.loweredFunc.func.context.length;
+    contextIdx++
+  ) {
+    const contextItem = fnExpr.loweredFunc.func.context[contextIdx];
+    const replacedCallee = replacedCallees.get(contextItem.identifier.id);
+    if (replacedCallee != null) {
+      fnExpr.loweredFunc.func.context[contextIdx] = replacedCallee;
+    }
+  }
+  context.mergeCalleesFromInnerScope(calleesCapturedByFnExpression);
+  return calleesCapturedByFnExpression;
+}
+function* eachReachablePlace(fn) {
+  for (const [, block] of fn.body.blocks) {
+    for (const instr of block.instructions) {
+      if (
+        instr.value.kind === 'FunctionExpression' ||
+        instr.value.kind === 'ObjectMethod'
+      ) {
+        yield* eachReachablePlace(instr.value.loweredFunc.func);
+      } else {
+        yield* eachInstructionOperand(instr);
+      }
+    }
+  }
+}
+function ensureNoRemainingCalleeCaptures(fn, context, capturedCallees) {
+  var _a;
+  for (const place of eachReachablePlace(fn)) {
+    const calleeInfo = capturedCallees.get(place.identifier.id);
+    if (calleeInfo != null) {
+      const calleeName =
+        ((_a = calleeInfo.capturedCalleeIdentifier.name) === null ||
+        _a === void 0
+          ? void 0
+          : _a.kind) === 'named'
+          ? calleeInfo.capturedCalleeIdentifier.name.value
+          : '<unknown>';
+      context.pushError({
+        loc: place.loc,
+        description: `All uses of ${calleeName} must be either used with a fire() call in this effect or not used with a fire() call at all. ${calleeName} was used with fire() on line ${printSourceLocationLine(calleeInfo.fireLoc)} in this effect`,
+        severity: exports.ErrorSeverity.InvalidReact,
+        reason: CANNOT_COMPILE_FIRE,
+        suggestions: null,
+      });
+    }
+  }
+}
+function ensureNoMoreFireUses(fn, context) {
+  for (const place of eachReachablePlace(fn)) {
+    if (
+      place.identifier.type.kind === 'Function' &&
+      place.identifier.type.shapeId === BuiltInFireId
+    ) {
+      context.pushError({
+        loc: place.identifier.loc,
+        description: 'Cannot use `fire` outside of a useEffect function',
+        severity: exports.ErrorSeverity.Invariant,
+        reason: CANNOT_COMPILE_FIRE,
+        suggestions: null,
+      });
+    }
+  }
+}
+function makeLoadUseFireInstruction(env) {
+  const useFirePlace = createTemporaryPlace(env, GeneratedSource);
+  useFirePlace.effect = exports.Effect.Read;
+  useFirePlace.identifier.type = DefaultNonmutatingHook;
+  const instrValue = {
+    kind: 'LoadGlobal',
+    binding: {
+      kind: 'ImportSpecifier',
+      name: 'useFire',
+      module: 'react',
+      imported: 'useFire',
+    },
+    loc: GeneratedSource,
+  };
+  return {
+    id: makeInstructionId(0),
+    value: instrValue,
+    lvalue: Object.assign({}, useFirePlace),
+    loc: GeneratedSource,
+  };
+}
+function makeLoadFireCalleeInstruction(env, fireCalleeIdentifier) {
+  const loadedFireCallee = createTemporaryPlace(env, GeneratedSource);
+  const fireCallee = {
+    kind: 'Identifier',
+    identifier: fireCalleeIdentifier,
+    reactive: false,
+    effect: exports.Effect.Unknown,
+    loc: fireCalleeIdentifier.loc,
+  };
+  return {
+    id: makeInstructionId(0),
+    value: {
+      kind: 'LoadLocal',
+      loc: GeneratedSource,
+      place: Object.assign({}, fireCallee),
+    },
+    lvalue: Object.assign({}, loadedFireCallee),
+    loc: GeneratedSource,
+  };
+}
+function makeCallUseFireInstruction(env, useFirePlace, argPlace) {
+  const useFireCallResultPlace = createTemporaryPlace(env, GeneratedSource);
+  useFireCallResultPlace.effect = exports.Effect.Read;
+  const useFireCall = {
+    kind: 'CallExpression',
+    callee: Object.assign({}, useFirePlace),
+    args: [argPlace],
+    loc: GeneratedSource,
+  };
+  return {
+    id: makeInstructionId(0),
+    value: useFireCall,
+    lvalue: Object.assign({}, useFireCallResultPlace),
+    loc: GeneratedSource,
+  };
+}
+function makeStoreUseFireInstruction(
+  env,
+  useFireCallResultPlace,
+  fireFunctionBindingPlace
+) {
+  promoteTemporary(fireFunctionBindingPlace.identifier);
+  const fireFunctionBindingLValuePlace = createTemporaryPlace(
+    env,
+    GeneratedSource
+  );
+  return {
+    id: makeInstructionId(0),
+    value: {
+      kind: 'StoreLocal',
+      lvalue: {
+        kind: InstructionKind.Const,
+        place: Object.assign({}, fireFunctionBindingPlace),
+      },
+      value: Object.assign({}, useFireCallResultPlace),
+      type: null,
+      loc: GeneratedSource,
+    },
+    lvalue: fireFunctionBindingLValuePlace,
+    loc: GeneratedSource,
+  };
+}
+class Context {
+  constructor(env) {
+    _Context_env.set(this, void 0);
+    _Context_errors.set(this, new CompilerError());
+    _Context_callExpressions.set(this, new Map());
+    _Context_functionExpressions.set(this, new Map());
+    _Context_loadLocals.set(this, new Map());
+    _Context_fireCalleesToFireFunctions.set(this, new Map());
+    _Context_calleesWithInsertedFire.set(this, new Set());
+    _Context_capturedCalleeIdentifierIds.set(this, new Map());
+    _Context_inUseEffectLambda.set(this, false);
+    _Context_loadGlobalInstructionIds.set(this, new Map());
+    _Context_arrayExpressions.set(this, new Map());
+    __classPrivateFieldSet(this, _Context_env, env, 'f');
+  }
+  pushError(error) {
+    __classPrivateFieldGet(this, _Context_errors, 'f').push(error);
+  }
+  withFunctionScope(fn) {
+    fn();
+    return __classPrivateFieldGet(
+      this,
+      _Context_capturedCalleeIdentifierIds,
+      'f'
+    );
+  }
+  withUseEffectLambdaScope(fn) {
+    const capturedCalleeIdentifierIds = __classPrivateFieldGet(
+      this,
+      _Context_capturedCalleeIdentifierIds,
+      'f'
+    );
+    const inUseEffectLambda = __classPrivateFieldGet(
+      this,
+      _Context_inUseEffectLambda,
+      'f'
+    );
+    __classPrivateFieldSet(
+      this,
+      _Context_capturedCalleeIdentifierIds,
+      new Map(),
+      'f'
+    );
+    __classPrivateFieldSet(this, _Context_inUseEffectLambda, true, 'f');
+    const resultCapturedCalleeIdentifierIds = this.withFunctionScope(fn);
+    __classPrivateFieldSet(
+      this,
+      _Context_capturedCalleeIdentifierIds,
+      capturedCalleeIdentifierIds,
+      'f'
+    );
+    __classPrivateFieldSet(
+      this,
+      _Context_inUseEffectLambda,
+      inUseEffectLambda,
+      'f'
+    );
+    return resultCapturedCalleeIdentifierIds;
+  }
+  addCallExpression(id, callExpr) {
+    __classPrivateFieldGet(this, _Context_callExpressions, 'f').set(
+      id,
+      callExpr
+    );
+  }
+  getCallExpression(id) {
+    return __classPrivateFieldGet(this, _Context_callExpressions, 'f').get(id);
+  }
+  addLoadLocalInstr(id, loadLocal) {
+    __classPrivateFieldGet(this, _Context_loadLocals, 'f').set(id, loadLocal);
+  }
+  getLoadLocalInstr(id) {
+    return __classPrivateFieldGet(this, _Context_loadLocals, 'f').get(id);
+  }
+  getOrGenerateFireFunctionBinding(callee, fireLoc) {
+    const fireFunctionBinding = getOrInsertWith(
+      __classPrivateFieldGet(this, _Context_fireCalleesToFireFunctions, 'f'),
+      callee.identifier.id,
+      () =>
+        createTemporaryPlace(
+          __classPrivateFieldGet(this, _Context_env, 'f'),
+          GeneratedSource
+        )
+    );
+    __classPrivateFieldGet(this, _Context_capturedCalleeIdentifierIds, 'f').set(
+      callee.identifier.id,
+      {
+        fireFunctionBinding: fireFunctionBinding,
+        capturedCalleeIdentifier: callee.identifier,
+        fireLoc: fireLoc,
+      }
+    );
+    return fireFunctionBinding;
+  }
+  mergeCalleesFromInnerScope(innerCallees) {
+    for (const [id, calleeInfo] of innerCallees.entries()) {
+      __classPrivateFieldGet(
+        this,
+        _Context_capturedCalleeIdentifierIds,
+        'f'
+      ).set(id, calleeInfo);
+    }
+  }
+  addCalleeWithInsertedFire(id) {
+    __classPrivateFieldGet(this, _Context_calleesWithInsertedFire, 'f').add(id);
+  }
+  hasCalleeWithInsertedFire(id) {
+    return __classPrivateFieldGet(
+      this,
+      _Context_calleesWithInsertedFire,
+      'f'
+    ).has(id);
+  }
+  inUseEffectLambda() {
+    return __classPrivateFieldGet(this, _Context_inUseEffectLambda, 'f');
+  }
+  addFunctionExpression(id, fn) {
+    __classPrivateFieldGet(this, _Context_functionExpressions, 'f').set(id, fn);
+  }
+  getFunctionExpression(id) {
+    return __classPrivateFieldGet(this, _Context_functionExpressions, 'f').get(
+      id
+    );
+  }
+  addLoadGlobalInstrId(id, instrId) {
+    __classPrivateFieldGet(this, _Context_loadGlobalInstructionIds, 'f').set(
+      id,
+      instrId
+    );
+  }
+  getLoadGlobalInstrId(id) {
+    return __classPrivateFieldGet(
+      this,
+      _Context_loadGlobalInstructionIds,
+      'f'
+    ).get(id);
+  }
+  addArrayExpression(id, array) {
+    __classPrivateFieldGet(this, _Context_arrayExpressions, 'f').set(id, array);
+  }
+  getArrayExpression(id) {
+    return __classPrivateFieldGet(this, _Context_arrayExpressions, 'f').get(id);
+  }
+  hasErrors() {
+    return __classPrivateFieldGet(this, _Context_errors, 'f').hasErrors();
+  }
+  throwIfErrorsFound() {
+    if (this.hasErrors())
+      throw __classPrivateFieldGet(this, _Context_errors, 'f');
+  }
+}
+(_Context_env = new WeakMap()),
+  (_Context_errors = new WeakMap()),
+  (_Context_callExpressions = new WeakMap()),
+  (_Context_functionExpressions = new WeakMap()),
+  (_Context_loadLocals = new WeakMap()),
+  (_Context_fireCalleesToFireFunctions = new WeakMap()),
+  (_Context_calleesWithInsertedFire = new WeakMap()),
+  (_Context_capturedCalleeIdentifierIds = new WeakMap()),
+  (_Context_inUseEffectLambda = new WeakMap()),
+  (_Context_loadGlobalInstructionIds = new WeakMap()),
+  (_Context_arrayExpressions = new WeakMap());
+function deleteInstructions(deleteInstrs, instructions) {
+  if (deleteInstrs.size > 0) {
+    const newInstrs = instructions.filter(instr => !deleteInstrs.has(instr.id));
+    return newInstrs;
+  }
+  return instructions;
+}
+function rewriteInstructions(rewriteInstrs, instructions) {
+  if (rewriteInstrs.size > 0) {
+    const newInstrs = [];
+    for (const instr of instructions) {
+      const newInstrsAtId = rewriteInstrs.get(instr.id);
+      if (newInstrsAtId != null) {
+        newInstrs.push(...newInstrsAtId, instr);
+      } else {
+        newInstrs.push(instr);
+      }
+    }
+    return newInstrs;
+  }
+  return instructions;
+}
 function run(
   func,
   config,
@@ -155873,6 +156508,10 @@ function runWithEnvironment(func, env) {
   if (env.config.validateHooksUsage) {
     validateHooksUsage(hir);
   }
+  if (env.config.enableFire) {
+    transformFire(hir);
+    log({kind: 'hir', name: 'TransformFire', value: hir});
+  }
   if (env.config.validateNoCapitalizedCalls) {
     validateNoCapitalizedCalls(hir);
   }
@@ -156624,6 +157263,13 @@ function compileProgram(program, pass) {
     if (environment.enableChangeDetectionForDebugging != null) {
       externalFunctions.push(environment.enableChangeDetectionForDebugging);
     }
+    const hasFireRewrite = compiledFns.some(c => c.compiledFn.hasFireRewrite);
+    if (environment.enableFire && hasFireRewrite) {
+      externalFunctions.push({
+        source: getReactCompilerRuntimeModule(pass.opts),
+        importSpecifierName: 'useFire',
+      });
+    }
   } catch (err) {
     handleError(err, pass, null);
     return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "babel-plugin-react-compiler",
-  "version": "0.0.0-experimental-22c6e49-20241220",
+  "version": "0.0.0-experimental-b2e8e9c-20241220",
   "description": "Babel plugin for React Compiler.",
   "main": "dist/index.js",
   "license": "MIT",