babel-plugin-react-compiler 19.0.0-beta-21e868a-20250216 → 19.0.0-beta-e1e972c-20250221

package/dist/index.js

@@ -6719,7 +6719,7 @@ var require_parentheses = __commonJS({
     exports2.DoExpression = DoExpression;
     exports2.FunctionExpression = FunctionExpression6;
     exports2.FunctionTypeAnnotation = FunctionTypeAnnotation;
-    exports2.Identifier = Identifier28;
+    exports2.Identifier = Identifier27;
     exports2.LogicalExpression = LogicalExpression;
     exports2.NullableTypeAnnotation = NullableTypeAnnotation;
     exports2.ObjectExpression = ObjectExpression;
@@ -6897,7 +6897,7 @@ var require_parentheses = __commonJS({
           return parent.operator !== "??";
       }
     }
-    function Identifier28(node, parent, tokenContext, _inForInit, getRawIdentifier) {
+    function Identifier27(node, parent, tokenContext, _inForInit, getRawIdentifier) {
       var _node$extra;
       const parentType = parent.type;
       if ((_node$extra = node.extra) != null && _node$extra.parenthesized && parentType === "AssignmentExpression" && parent.left === node) {
@@ -8853,7 +8853,7 @@ var require_types = __commonJS({
     exports2.BigIntLiteral = BigIntLiteral;
     exports2.BooleanLiteral = BooleanLiteral;
     exports2.DecimalLiteral = DecimalLiteral;
-    exports2.Identifier = Identifier28;
+    exports2.Identifier = Identifier27;
     exports2.NullLiteral = NullLiteral;
     exports2.NumericLiteral = NumericLiteral;
     exports2.ObjectPattern = exports2.ObjectExpression = ObjectExpression;
@@ -8890,7 +8890,7 @@ var require_types = __commonJS({
       }
       return lastRawIdentResult = node.name;
     }
-    function Identifier28(node) {
+    function Identifier27(node) {
       var _node$loc;
       this.sourceIdentifierName(((_node$loc = node.loc) == null ? void 0 : _node$loc.identifierName) || node.name);
       this.word(this.tokenMap ? this._getRawIdentifier(node) : node.name);
@@ -52492,7 +52492,7 @@ var require_parentheses2 = __commonJS({
     exports2.DoExpression = DoExpression;
     exports2.FunctionExpression = FunctionExpression6;
     exports2.FunctionTypeAnnotation = FunctionTypeAnnotation;
-    exports2.Identifier = Identifier28;
+    exports2.Identifier = Identifier27;
     exports2.LogicalExpression = LogicalExpression;
     exports2.NullableTypeAnnotation = NullableTypeAnnotation;
     exports2.ObjectExpression = ObjectExpression;
@@ -52670,7 +52670,7 @@ var require_parentheses2 = __commonJS({
           return parent.operator !== "??";
       }
     }
-    function Identifier28(node, parent, tokenContext, _inForInit, getRawIdentifier) {
+    function Identifier27(node, parent, tokenContext, _inForInit, getRawIdentifier) {
       var _node$extra;
       const parentType = parent.type;
       if ((_node$extra = node.extra) != null && _node$extra.parenthesized && parentType === "AssignmentExpression" && parent.left === node) {
@@ -54626,7 +54626,7 @@ var require_types2 = __commonJS({
     exports2.BigIntLiteral = BigIntLiteral;
     exports2.BooleanLiteral = BooleanLiteral;
     exports2.DecimalLiteral = DecimalLiteral;
-    exports2.Identifier = Identifier28;
+    exports2.Identifier = Identifier27;
     exports2.NullLiteral = NullLiteral;
     exports2.NumericLiteral = NumericLiteral;
     exports2.ObjectPattern = exports2.ObjectExpression = ObjectExpression;
@@ -54663,7 +54663,7 @@ var require_types2 = __commonJS({
       }
       return lastRawIdentResult = node.name;
     }
-    function Identifier28(node) {
+    function Identifier27(node) {
       var _node$loc;
       this.sourceIdentifierName(((_node$loc = node.loc) == null ? void 0 : _node$loc.identifierName) || node.name);
       this.word(this.tokenMap ? this._getRawIdentifier(node) : node.name);
@@ -98137,7 +98137,7 @@ var require_types3 = __commonJS({
     Object.defineProperty(exports2, "__esModule", {
       value: true
     });
-    exports2.Identifier = Identifier28;
+    exports2.Identifier = Identifier27;
     exports2.SpreadElement = exports2.RestElement = RestElement;
     exports2.ObjectPattern = exports2.ObjectExpression = ObjectExpression;
     exports2.ObjectMethod = ObjectMethod3;
@@ -98187,7 +98187,7 @@ var require_types3 = __commonJS({
         return newObj;
       }
     }
-    function Identifier28(node) {
+    function Identifier27(node) {
       this.exactSource(node.loc, () => {
         this.word(node.name);
       });
@@ -117642,6 +117642,10 @@ function isMutableEffect(effect, location) {
     }
   }
 }
+var opaquePropertyLiteral = Symbol();
+function makePropertyLiteral(value) {
+  return value;
+}
 function areEqualPaths(a, b) {
   return a.length === b.length && a.every(
     (item, ix) => item.property === b[ix].property && item.optional === b[ix].optional
@@ -118562,7 +118566,6 @@ function printInstructionValue(instrValue) {
       const kind = instrValue.kind === "FunctionExpression" ? "Function" : "ObjectMethod";
       const name2 = getFunctionName(instrValue, "");
       const fn = printFunction(instrValue.loweredFunc.func).split("\n").map((line) => `      ${line}`).join("\n");
-      const deps = instrValue.loweredFunc.dependencies.map((dep) => printPlace(dep)).join(",");
       const context = instrValue.loweredFunc.func.context.map((dep) => printPlace(dep)).join(",");
       const effects = instrValue.loweredFunc.func.effects?.map((effect) => {
         if (effect.kind === "ContextMutation") {
@@ -118572,7 +118575,7 @@ function printInstructionValue(instrValue) {
         }
       }).join(", ") ?? "";
       const type = printType(instrValue.loweredFunc.func.returnType).trim();
-      value = `${kind} ${name2} @deps[${deps}] @context[${context}] @effects[${effects}]${type !== "" ? ` return${type}` : ""}:
+      value = `${kind} ${name2} @context[${context}] @effects[${effects}]${type !== "" ? ` return${type}` : ""}:
 ${fn}`;
       break;
     }
@@ -118713,10 +118716,6 @@ ${fn}`;
       value = `FinishMemoize decl=${printPlace(instrValue.decl)}`;
       break;
     }
-    case "ReactiveFunctionValue": {
-      value = `FunctionValue ${printReactiveFunction(instrValue.fn)}`;
-      break;
-    }
     default: {
       assertExhaustive(
         instrValue,
@@ -119013,7 +119012,7 @@ function* eachInstructionValueOperand(instrValue) {
     }
     case "ObjectMethod":
     case "FunctionExpression": {
-      yield* instrValue.loweredFunc.dependencies;
+      yield* instrValue.loweredFunc.func.context;
       break;
     }
     case "TaggedTemplateExpression": {
@@ -119317,7 +119316,7 @@ function mapInstructionValueOperands(instrValue, fn) {
     }
     case "ObjectMethod":
     case "FunctionExpression": {
-      instrValue.loweredFunc.dependencies = instrValue.loweredFunc.dependencies.map((d) => fn(d));
+      instrValue.loweredFunc.func.context = instrValue.loweredFunc.func.context.map((d) => fn(d));
       break;
     }
     case "TaggedTemplateExpression": {
@@ -123201,11 +123200,11 @@ function lowerExpression(builder, exprPath) {
             right: lowerExpressionToTemporary(builder, expr.get("right")),
             loc: leftExpr.node.loc ?? GeneratedSource
           });
-          if (typeof property === "string") {
+          if (typeof property === "string" || typeof property === "number") {
             return {
               kind: "PropertyStore",
               object: { ...object },
-              property,
+              property: makePropertyLiteral(property),
               value: { ...newValuePlace },
               loc: leftExpr.node.loc ?? GeneratedSource
             };
@@ -123470,11 +123469,11 @@ function lowerExpression(builder, exprPath) {
         const argument = expr.get("argument");
         if (argument.isMemberExpression()) {
           const { object, property } = lowerMemberExpression(builder, argument);
-          if (typeof property === "string") {
+          if (typeof property === "string" || typeof property === "number") {
             return {
               kind: "PropertyDelete",
               object,
-              property,
+              property: makePropertyLiteral(property),
               loc: exprLoc
             };
           } else {
@@ -123576,11 +123575,11 @@ function lowerExpression(builder, exprPath) {
           loc: leftExpr.node.loc ?? GeneratedSource
         });
         let newValuePlace;
-        if (typeof property === "string") {
+        if (typeof property === "string" || typeof property === "number") {
           newValuePlace = lowerValueToTemporary(builder, {
             kind: "PropertyStore",
             object: { ...object },
-            property,
+            property: makePropertyLiteral(property),
             value: { ...updatedValue },
             loc: leftExpr.node.loc ?? GeneratedSource
           });
@@ -124084,8 +124083,13 @@ function lowerMemberExpression(builder, expr, loweredObject = null) {
   const objectNode = expr.get("object");
   const propertyNode = expr.get("property");
   const object = loweredObject ?? lowerExpressionToTemporary(builder, objectNode);
-  if (!expr.node.computed) {
-    if (!propertyNode.isIdentifier()) {
+  if (!expr.node.computed || expr.node.property.type === "NumericLiteral") {
+    let property;
+    if (propertyNode.isIdentifier()) {
+      property = makePropertyLiteral(propertyNode.node.name);
+    } else if (propertyNode.isNumericLiteral()) {
+      property = makePropertyLiteral(propertyNode.node.value);
+    } else {
       builder.errors.push({
         reason: `(BuildHIR::lowerMemberExpression) Handle ${propertyNode.type} property`,
         severity: "Todo" /* Todo */,
@@ -124101,10 +124105,10 @@ function lowerMemberExpression(builder, expr, loweredObject = null) {
     const value = {
       kind: "PropertyLoad",
       object: { ...object },
-      property: propertyNode.node.name,
+      property,
       loc: exprLoc
     };
-    return { object, property: propertyNode.node.name, value };
+    return { object, property, value };
   } else {
     if (!propertyNode.isExpression()) {
       builder.errors.push({
@@ -124211,7 +124215,7 @@ function lowerJsxMemberExpression(builder, exprPath) {
   return lowerValueToTemporary(builder, {
     kind: "PropertyLoad",
     object: objectPlace,
-    property,
+    property: makePropertyLiteral(property),
     loc
   });
 }
@@ -124319,12 +124323,12 @@ function lowerFunctionToValue(builder, expr) {
 }
 function lowerFunction(builder, expr) {
   const componentScope = builder.parentFunction.scope;
-  const captured = gatherCapturedDeps(builder, expr, componentScope);
+  const capturedContext = gatherCapturedContext(expr, componentScope);
   const lowering = lower(
     expr,
     builder.environment,
     builder.bindings,
-    [...builder.context, ...captured.identifiers],
+    [...builder.context, ...capturedContext],
     builder.parentFunction
   );
   let loweredFunc;
@@ -124334,8 +124338,7 @@ function lowerFunction(builder, expr) {
   }
   loweredFunc = lowering.unwrap();
   return {
-    func: loweredFunc,
-    dependencies: captured.refs
+    func: loweredFunc
   };
 }
 function lowerExpressionToTemporary(builder, exprPath) {
@@ -124511,8 +124514,25 @@ function lowerAssignment(builder, loc, kind, lvaluePath, value, assignmentKind)
       const lvalue = lvaluePath;
       const property = lvalue.get("property");
       const object = lowerExpressionToTemporary(builder, lvalue.get("object"));
-      if (!lvalue.node.computed) {
-        if (!property.isIdentifier()) {
+      if (!lvalue.node.computed || lvalue.get("property").isNumericLiteral()) {
+        let temporary;
+        if (property.isIdentifier()) {
+          temporary = lowerValueToTemporary(builder, {
+            kind: "PropertyStore",
+            object,
+            property: makePropertyLiteral(property.node.name),
+            value,
+            loc
+          });
+        } else if (property.isNumericLiteral()) {
+          temporary = lowerValueToTemporary(builder, {
+            kind: "PropertyStore",
+            object,
+            property: makePropertyLiteral(property.node.value),
+            value,
+            loc
+          });
+        } else {
           builder.errors.push({
             reason: `(BuildHIR::lowerAssignment) Handle ${property.type} properties in MemberExpression`,
             severity: "Todo" /* Todo */,
@@ -124521,13 +124541,6 @@ function lowerAssignment(builder, loc, kind, lvaluePath, value, assignmentKind)
           });
           return { kind: "UnsupportedNode", node: lvalueNode, loc };
         }
-        const temporary = lowerValueToTemporary(builder, {
-          kind: "PropertyStore",
-          object,
-          property: property.node.name,
-          value,
-          loc
-        });
         return { kind: "LoadLocal", place: temporary, loc: temporary.loc };
       } else {
         if (!property.isExpression()) {
@@ -124901,10 +124914,6 @@ function lowerAssignment(builder, loc, kind, lvaluePath, value, assignmentKind)
     }
   }
 }
-function isValidDependency(path) {
-  const parent = path.parentPath;
-  return !path.node.computed && !(parent.isCallExpression() && parent.get("callee") === path);
-}
 function captureScopes({ from, to }) {
   let scopes = /* @__PURE__ */ new Set();
   while (from) {
@@ -124916,26 +124925,14 @@ function captureScopes({ from, to }) {
   }
   return scopes;
 }
-function gatherCapturedDeps(builder, fn, componentScope) {
-  const capturedIds = /* @__PURE__ */ new Map();
-  const capturedRefs = /* @__PURE__ */ new Set();
-  const seenPaths = /* @__PURE__ */ new Set();
+function gatherCapturedContext(fn, componentScope) {
+  const capturedIds = /* @__PURE__ */ new Set();
   const pureScopes = captureScopes({
     from: fn.scope.parent,
     to: componentScope
   });
-  function addCapturedId(bindingIdentifier) {
-    if (!capturedIds.has(bindingIdentifier)) {
-      const index = capturedIds.size;
-      capturedIds.set(bindingIdentifier, index);
-      return index;
-    } else {
-      return capturedIds.get(bindingIdentifier);
-    }
-  }
   function handleMaybeDependency(path) {
     let baseIdentifier;
-    let dependency;
     if (path.isJSXOpeningElement()) {
       const name2 = path.get("name");
       if (!(name2.isJSXMemberExpression() || name2.isJSXIdentifier())) {
@@ -124950,79 +124947,13 @@ function gatherCapturedDeps(builder, fn, componentScope) {
         "Invalid logic in gatherCapturedDeps"
       );
       baseIdentifier = current;
-      let currentDep = baseIdentifier;
-      while (true) {
-        const nextDep = currentDep.parentPath;
-        if (nextDep && nextDep.isJSXMemberExpression()) {
-          currentDep = nextDep;
-        } else {
-          break;
-        }
-      }
-      dependency = currentDep;
-    } else if (path.isMemberExpression()) {
-      let currentId = path;
-      while (currentId.isMemberExpression()) {
-        currentId = currentId.get("object");
-      }
-      if (!currentId.isIdentifier()) {
-        return;
-      }
-      baseIdentifier = currentId;
-      let currentDep = baseIdentifier;
-      while (true) {
-        const nextDep = currentDep.parentPath;
-        if (nextDep && nextDep.isMemberExpression() && isValidDependency(nextDep)) {
-          currentDep = nextDep;
-        } else {
-          break;
-        }
-      }
-      dependency = currentDep;
     } else {
       baseIdentifier = path;
-      dependency = path;
     }
-    dependency.skip();
+    path.skip();
     const binding = baseIdentifier.scope.getBinding(baseIdentifier.node.name);
-    if (binding === void 0 || !pureScopes.has(binding.scope)) {
-      return;
-    }
-    const idKey = String(addCapturedId(binding.identifier));
-    let exprKey = idKey;
-    if (dependency.isMemberExpression()) {
-      let pathTokens = [];
-      let current = dependency;
-      while (current.isMemberExpression()) {
-        const property = current.get("property");
-        pathTokens.push(property.node.name);
-        current = current.get("object");
-      }
-      exprKey += "." + pathTokens.reverse().join(".");
-    } else if (dependency.isJSXMemberExpression()) {
-      let pathTokens = [];
-      let current = dependency;
-      while (current.isJSXMemberExpression()) {
-        const property = current.get("property");
-        pathTokens.push(property.node.name);
-        current = current.get("object");
-      }
-    }
-    if (!seenPaths.has(exprKey)) {
-      let loweredDep;
-      if (dependency.isJSXIdentifier()) {
-        loweredDep = lowerValueToTemporary(builder, {
-          kind: "LoadLocal",
-          place: lowerIdentifier(builder, dependency),
-          loc: path.node.loc ?? GeneratedSource
-        });
-      } else if (dependency.isJSXMemberExpression()) {
-        loweredDep = lowerJsxMemberExpression(builder, dependency);
-      } else {
-        loweredDep = lowerExpressionToTemporary(builder, dependency);
-      }
-      capturedRefs.add(loweredDep);
-      seenPaths.add(exprKey);
+    if (binding !== void 0 && pureScopes.has(binding.scope)) {
+      capturedIds.add(binding.identifier);
     }
   }
   fn.traverse({
@@ -125047,12 +124978,12 @@ function gatherCapturedDeps(builder, fn, componentScope) {
         return;
       } else if (path.isJSXElement()) {
         handleMaybeDependency(path.get("openingElement"));
-      } else if (path.isMemberExpression() || path.isIdentifier()) {
+      } else if (path.isIdentifier()) {
         handleMaybeDependency(path);
       }
     }
   });
-  return { identifiers: [...capturedIds.keys()], refs: [...capturedRefs] };
+  return [...capturedIds.keys()];
 }
 function notNull(value) {
   return value !== null;
@@ -126322,7 +126253,6 @@ var EnvironmentConfigSchema = z.object({
    * enables trusting user type annotations.
    */
   enableUseTypeAnnotations: z.boolean().default(false),
-  enableFunctionDependencyRewrite: z.boolean().default(true),
   /**
    * Enables inference of optional dependency chains. Without this flag
    * a property chain such as `props?.items?.foo` will infer as a dep on
@@ -127518,6 +127448,11 @@ function findDisjointMutableValues(fn) {
            * TODO: improve handling of module-scoped variables and globals
            */
           operand.identifier.mutableRange.start > 0) {
+            if (instr.value.kind === "FunctionExpression" || instr.value.kind === "ObjectMethod") {
+              if (operand.identifier.type.kind === "Primitive") {
+                continue;
+              }
+            }
             operands.push(operand.identifier);
           }
         }
@@ -127637,6 +127572,9 @@ function getOverlappingReactiveScopes(fn, context) {
     for (const instr of block.instructions) {
       visitInstructionId(instr.id, context, state);
       for (const place of eachInstructionOperand(instr)) {
+        if ((instr.value.kind === "FunctionExpression" || instr.value.kind === "ObjectMethod") && place.identifier.type.kind === "Primitive") {
+          continue;
+        }
         visitPlace(instr.id, place, state);
       }
       for (const place of eachInstructionLValue(instr)) {
@@ -128122,6 +128060,7 @@ function nonNull(t5) {
 var import_types2 = require("@babel/types");
 
 // src/SSA/EliminateRedundantPhi.ts
+var DEBUG = false;
 function eliminateRedundantPhi(fn, sharedRewrites) {
   const ir = fn.body;
   const rewrites = sharedRewrites != null ? sharedRewrites : /* @__PURE__ */ new Map();
@@ -128181,6 +128120,22 @@ function eliminateRedundantPhi(fn, sharedRewrites) {
       }
     }
   } while (rewrites.size > size && hasBackEdge2);
+  if (DEBUG) {
+    for (const [, block] of ir.blocks) {
+      for (const phi of block.phis) {
+        CompilerError.invariant(!rewrites.has(phi.place.identifier), {
+          reason: "[EliminateRedundantPhis]: rewrite not complete",
+          loc: phi.place.loc
+        });
+        for (const [, operand] of phi.operands) {
+          CompilerError.invariant(!rewrites.has(operand.identifier), {
+            reason: "[EliminateRedundantPhis]: rewrite not complete",
+            loc: phi.place.loc
+          });
+        }
+      }
+    }
+  }
 }
 function rewritePlace(place, rewrites) {
   const rewrite = rewrites.get(place.identifier);
@@ -128398,9 +128353,6 @@ function enterSSAImpl(func, builder, rootEntry) {
         entry.preds.add(blockId);
         builder.defineFunction(loweredFunc);
         builder.enter(() => {
-          loweredFunc.context = loweredFunc.context.map(
-            (p) => builder.getPlace(p)
-          );
           loweredFunc.params = loweredFunc.params.map((param) => {
             if (param.kind === "Identifier") {
               return builder.definePlace(param);
@@ -128706,11 +128658,11 @@ function evaluateInstruction(constants, instr) {
     }
     case "ComputedLoad": {
       const property = read(constants, value.property);
-      if (property !== null && property.kind === "Primitive" && typeof property.value === "string" && (0, import_types2.isValidIdentifier)(property.value)) {
+      if (property !== null && property.kind === "Primitive" && (typeof property.value === "string" && (0, import_types2.isValidIdentifier)(property.value) || typeof property.value === "number")) {
         const nextValue = {
           kind: "PropertyLoad",
           loc: value.loc,
-          property: property.value,
+          property: makePropertyLiteral(property.value),
           object: value.object
         };
         instr.value = nextValue;
@@ -128719,11 +128671,11 @@ function evaluateInstruction(constants, instr) {
     }
     case "ComputedStore": {
       const property = read(constants, value.property);
-      if (property !== null && property.kind === "Primitive" && typeof property.value === "string" && (0, import_types2.isValidIdentifier)(property.value)) {
+      if (property !== null && property.kind === "Primitive" && (typeof property.value === "string" && (0, import_types2.isValidIdentifier)(property.value) || typeof property.value === "number")) {
         const nextValue = {
           kind: "PropertyStore",
           loc: value.loc,
-          property: property.value,
+          property: makePropertyLiteral(property.value),
           object: value.object,
           value: value.value
         };
@@ -129615,7 +129567,7 @@ function createSymbolProperty(fn, instr, nextInstructions, propertyName, symbolN
     value: {
       kind: "PropertyLoad",
       object: { ...symbolInstruction.lvalue },
-      property: "for",
+      property: makePropertyLiteral("for"),
       loc: instr.value.loc
     },
     loc: instr.loc
@@ -129990,15 +129942,6 @@ var ReactiveFunctionVisitor = class {
         this.visitValue(value.id, value.value, state);
         break;
       }
-      case "ReactiveFunctionValue": {
-        this.visitReactiveFunctionValue(
-          id,
-          value.dependencies,
-          value.fn,
-          state
-        );
-        break;
-      }
       default: {
         for (const place of eachInstructionValueOperand(value)) {
           this.visitPlace(id, place, state);
@@ -130294,18 +130237,6 @@ var ReactiveFunctionTransform = class extends ReactiveFunctionVisitor {
         }
         break;
       }
-      case "ReactiveFunctionValue": {
-        const nextValue = this.transformReactiveFunctionValue(
-          id,
-          value.dependencies,
-          value.fn,
-          state
-        );
-        if (nextValue.kind === "replace") {
-          value.fn = nextValue.value;
-        }
-        break;
-      }
       default: {
         for (const place of eachInstructionValueOperand(value)) {
           this.visitPlace(id, place, state);
@@ -130468,10 +130399,6 @@ function* eachReactiveValueOperand(instrValue) {
       yield* eachReactiveValueOperand(instrValue.alternate);
       break;
     }
-    case "ReactiveFunctionValue": {
-      yield* instrValue.dependencies;
-      break;
-    }
     default: {
       yield* eachInstructionValueOperand(instrValue);
     }
@@ -133061,15 +132988,17 @@ function codegenDependency(cx, dependency) {
   if (dependency.path.length !== 0) {
     const hasOptional = dependency.path.some((path) => path.optional);
     for (const path of dependency.path) {
+      const property = typeof path.property === "string" ? t4.identifier(path.property) : t4.numericLiteral(path.property);
+      const isComputed = typeof path.property !== "string";
       if (hasOptional) {
         object = t4.optionalMemberExpression(
           object,
-          t4.identifier(path.property),
-          false,
+          property,
+          isComputed,
           path.optional
         );
       } else {
-        object = t4.memberExpression(object, t4.identifier(path.property));
+        object = t4.memberExpression(object, property, isComputed);
       }
     }
   }
@@ -133481,34 +133410,33 @@ function codegenInstructionValue(cx, instrValue) {
       value = node;
       break;
     }
-    case "PropertyStore": {
-      value = t4.assignmentExpression(
-        "=",
-        t4.memberExpression(
-          codegenPlaceToExpression(cx, instrValue.object),
-          t4.identifier(instrValue.property)
-        ),
-        codegenPlaceToExpression(cx, instrValue.value)
-      );
-      break;
-    }
-    case "PropertyLoad": {
-      const object = codegenPlaceToExpression(cx, instrValue.object);
-      value = t4.memberExpression(
-        object,
-        t4.identifier(instrValue.property),
-        void 0
-      );
-      break;
-    }
+    case "PropertyStore":
+    case "PropertyLoad":
     case "PropertyDelete": {
-      value = t4.unaryExpression(
-        "delete",
-        t4.memberExpression(
+      let memberExpr;
+      if (typeof instrValue.property === "string") {
+        memberExpr = t4.memberExpression(
           codegenPlaceToExpression(cx, instrValue.object),
           t4.identifier(instrValue.property)
-        )
-      );
+        );
+      } else {
+        memberExpr = t4.memberExpression(
+          codegenPlaceToExpression(cx, instrValue.object),
+          t4.numericLiteral(instrValue.property),
+          true
+        );
+      }
+      if (instrValue.kind === "PropertyStore") {
+        value = t4.assignmentExpression(
+          "=",
+          memberExpr,
+          codegenPlaceToExpression(cx, instrValue.value)
+        );
+      } else if (instrValue.kind === "PropertyLoad") {
+        value = memberExpr;
+      } else {
+        value = t4.unaryExpression("delete", memberExpr);
+      }
       break;
     }
     case "ComputedStore": {
@@ -133743,7 +133671,6 @@ function codegenInstructionValue(cx, instrValue) {
       );
       break;
     }
-    case "ReactiveFunctionValue":
     case "StartMemoize":
     case "FinishMemoize":
     case "Debugger":
@@ -134133,9 +134060,9 @@ function mergeReactiveScopesThatInvalidateTogether(fn) {
   visitReactiveFunction(fn, lastUsageVisitor, void 0);
   visitReactiveFunction(fn, new Transform(lastUsageVisitor.lastUsage), null);
 }
-var DEBUG = false;
+var DEBUG2 = false;
 function log(msg) {
-  if (DEBUG) {
+  if (DEBUG2) {
     console.log(msg);
   }
 }
@@ -134802,7 +134729,7 @@ var Transform2 = class extends ReactiveFunctionTransform {
               value: {
                 kind: "PropertyLoad",
                 object: { ...symbolTemp },
-                property: "for",
+                property: makePropertyLiteral("for"),
                 loc
               }
             }
@@ -135454,20 +135381,19 @@ var InferenceState = class _InferenceState {
   }
   freezeValues(values, reason) {
     for (const value of values) {
+      if (value.kind === "DeclareContext") {
+        continue;
+      }
       this.#values.set(value, {
         kind: "frozen" /* Frozen */,
         reason,
         context: /* @__PURE__ */ new Set()
       });
-      if (value.kind === "FunctionExpression") {
-        if (this.#env.config.enablePreserveExistingMemoizationGuarantees || this.#env.config.enableTransitivelyFreezeFunctionExpressions) {
-          if (value.kind === "FunctionExpression") {
-            for (const operand of eachInstructionValueOperand(value)) {
-              const operandValues = this.#variables.get(operand.identifier.id);
-              if (operandValues !== void 0) {
-                this.freezeValues(operandValues, reason);
-              }
-            }
+      if (value.kind === "FunctionExpression" && (this.#env.config.enablePreserveExistingMemoizationGuarantees || this.#env.config.enableTransitivelyFreezeFunctionExpressions)) {
+        for (const operand of value.loweredFunc.func.context) {
+          const operandValues = this.#variables.get(operand.identifier.id);
+          if (operandValues !== void 0) {
+            this.freezeValues(operandValues, reason);
           }
         }
       }
@@ -136025,17 +135951,17 @@ function inferBlock(env, state, block, functionEffects) {
       case "ObjectMethod":
       case "FunctionExpression": {
         let hasMutableOperand = false;
-        const mutableOperands = [];
         for (const operand of eachInstructionOperand(instr)) {
+          CompilerError.invariant(operand.effect !== "<unknown>" /* Unknown */, {
+            reason: "Expected fn effects to be populated",
+            loc: operand.loc
+          });
           state.referenceAndRecordEffects(
             freezeActions,
             operand,
-            operand.effect === "<unknown>" /* Unknown */ ? "read" /* Read */ : operand.effect,
+            operand.effect,
             "other" /* Other */
           );
-          if (isMutableEffect(operand.effect, operand.loc)) {
-            mutableOperands.push(operand);
-          }
           hasMutableOperand ||= isMutableEffect(operand.effect, operand.loc);
         }
         state.initialize(instrValue, {
@@ -136411,13 +136337,6 @@ function inferBlock(env, state, block, functionEffects) {
       }
       case "LoadLocal": {
         const lvalue = instr.lvalue;
-        CompilerError.invariant(
-          !(state.isDefined(lvalue) && state.kind(lvalue).kind === "context" /* Context */),
-          {
-            reason: "[InferReferenceEffects] Unexpected LoadLocal with context kind",
-            loc: lvalue.loc
-          }
-        );
         state.referenceAndRecordEffects(
           freezeActions,
           instrValue.place,
@@ -137212,14 +137131,6 @@ function computeMemoizationInputs(env, value, lvalue, options) {
         rvalues: operands
       };
     }
-    case "ReactiveFunctionValue": {
-      CompilerError.invariant(false, {
-        reason: `Unexpected ReactiveFunctionValue node`,
-        description: null,
-        loc: value.loc,
-        suggestions: null
-      });
-    }
     case "UnsupportedNode": {
       CompilerError.invariant(false, {
         reason: `Unexpected unsupported node`,
@@ -137810,56 +137721,6 @@ var RewriteBlockIds = class extends ReactiveFunctionVisitor {
   }
 };
 
-// src/Inference/InferMutableContextVariables.ts
-function inferMutableContextVariables(fn) {
-  const state = new IdentifierState();
-  const knownMutatedIdentifiers = /* @__PURE__ */ new Set();
-  for (const [, block] of fn.body.blocks) {
-    for (const instr of block.instructions) {
-      switch (instr.value.kind) {
-        case "PropertyLoad": {
-          state.declareProperty(
-            instr.lvalue,
-            instr.value.object,
-            instr.value.property
-          );
-          break;
-        }
-        case "ComputedLoad": {
-          state.declareProperty(instr.lvalue, instr.value.object, "");
-          break;
-        }
-        case "LoadLocal":
-        case "LoadContext": {
-          if (instr.lvalue.identifier.name === null) {
-            state.declareTemporary(instr.lvalue, instr.value.place);
-          }
-          break;
-        }
-        default: {
-          for (const operand of eachInstructionValueOperand(instr.value)) {
-            visitOperand(state, knownMutatedIdentifiers, operand);
-          }
-        }
-      }
-    }
-    for (const operand of eachTerminalOperand(block.terminal)) {
-      visitOperand(state, knownMutatedIdentifiers, operand);
-    }
-  }
-  for (const operand of fn.context) {
-    if (knownMutatedIdentifiers.has(operand.identifier)) {
-      operand.effect = "mutate" /* Mutate */;
-    }
-  }
-}
-function visitOperand(state, knownMutatedIdentifiers, operand) {
-  const resolved = state.resolve(operand.identifier);
-  if (operand.effect === "mutate" /* Mutate */ || operand.effect === "store" /* Store */) {
-    knownMutatedIdentifiers.add(resolved);
-  }
-}
-
 // src/Inference/InferAlias.ts
 function inferAliases(func) {
   const aliases = new DisjointSet();
@@ -138123,65 +137984,18 @@ function areEqualMaps(a, b) {
 }
 
 // src/Inference/AnalyseFunctions.ts
-var IdentifierState = class {
-  constructor() {
-    this.properties = /* @__PURE__ */ new Map();
-  }
-  resolve(identifier4) {
-    const resolved = this.properties.get(identifier4);
-    if (resolved !== void 0) {
-      return resolved.identifier;
-    }
-    return identifier4;
-  }
-  declareProperty(lvalue, object, property) {
-    const objectDependency = this.properties.get(object.identifier);
-    let nextDependency;
-    if (objectDependency === void 0) {
-      nextDependency = { identifier: object.identifier, path: [property] };
-    } else {
-      nextDependency = {
-        identifier: objectDependency.identifier,
-        path: [...objectDependency.path, property]
-      };
-    }
-    this.properties.set(lvalue.identifier, nextDependency);
-  }
-  declareTemporary(lvalue, value) {
-    const resolved = this.properties.get(value.identifier) ?? {
-      identifier: value.identifier,
-      path: []
-    };
-    this.properties.set(lvalue.identifier, resolved);
-  }
-};
 function analyseFunctions(func) {
-  const state = new IdentifierState();
   for (const [_, block] of func.body.blocks) {
     for (const instr of block.instructions) {
       switch (instr.value.kind) {
         case "ObjectMethod":
         case "FunctionExpression": {
           lower2(instr.value.loweredFunc.func);
-          infer2(instr.value.loweredFunc, state, func.context);
-          break;
-        }
-        case "PropertyLoad": {
-          state.declareProperty(
-            instr.lvalue,
-            instr.value.object,
-            instr.value.property
-          );
-          break;
-        }
-        case "ComputedLoad": {
-          state.declareProperty(instr.lvalue, instr.value.object, "");
-          break;
-        }
-        case "LoadLocal":
-        case "LoadContext": {
-          if (instr.lvalue.identifier.name === null) {
-            state.declareTemporary(instr.lvalue, instr.value.place);
+          infer2(instr.value.loweredFunc);
+          for (const operand of instr.value.loweredFunc.func.context) {
+            operand.identifier.mutableRange.start = makeInstructionId(0);
+            operand.identifier.mutableRange.end = makeInstructionId(0);
+            operand.identifier.scope = null;
           }
           break;
         }
@@ -138196,55 +138010,27 @@ function lower2(func) {
   inferMutableRanges(func);
   rewriteInstructionKindsBasedOnReassignment(func);
   inferReactiveScopeVariables(func);
-  inferMutableContextVariables(func);
   func.env.logger?.debugLogIRs?.({
     kind: "hir",
     name: "AnalyseFunction (inner)",
     value: func
   });
 }
-function infer2(loweredFunc, state, context) {
-  const mutations = /* @__PURE__ */ new Map();
+function infer2(loweredFunc) {
   for (const operand of loweredFunc.func.context) {
-    if (isMutatedOrReassigned(operand.identifier) && operand.identifier.name !== null) {
-      mutations.set(operand.identifier.name.value, operand.effect);
-    }
-  }
-  for (const dep of loweredFunc.dependencies) {
-    let name2 = null;
-    if (state.properties.has(dep.identifier)) {
-      const receiver = state.properties.get(dep.identifier);
-      name2 = receiver.identifier.name;
+    const identifier4 = operand.identifier;
+    CompilerError.invariant(operand.effect === "<unknown>" /* Unknown */, {
+      reason: "[AnalyseFunctions] Expected Function context effects to not have been set",
+      loc: operand.loc
+    });
+    if (isRefOrRefValue(identifier4)) {
+      operand.effect = "capture" /* Capture */;
+    } else if (isMutatedOrReassigned(identifier4)) {
+      operand.effect = "capture" /* Capture */;
     } else {
-      name2 = dep.identifier.name;
-    }
-    if (isRefOrRefValue(dep.identifier)) {
-      dep.effect = "capture" /* Capture */;
-    } else if (name2 !== null) {
-      const effect = mutations.get(name2.value);
-      if (effect !== void 0) {
-        dep.effect = effect === "<unknown>" /* Unknown */ ? "capture" /* Capture */ : effect;
-      }
+      operand.effect = "read" /* Read */;
     }
   }
-  for (const place of context) {
-    CompilerError.invariant(place.identifier.name !== null, {
-      reason: "context refs should always have a name",
-      description: null,
-      loc: place.loc,
-      suggestions: null
-    });
-    const effect = mutations.get(place.identifier.name.value);
-    if (effect !== void 0) {
-      place.effect = effect === "<unknown>" /* Unknown */ ? "capture" /* Capture */ : effect;
-      loweredFunc.dependencies.push(place);
-    }
-  }
-  for (const operand of loweredFunc.func.context) {
-    operand.identifier.mutableRange.start = makeInstructionId(0);
-    operand.identifier.mutableRange.end = makeInstructionId(0);
-    operand.identifier.scope = null;
-  }
 }
 function isMutatedOrReassigned(id) {
   return id.mutableRange.end > id.mutableRange.start;
@@ -138328,9 +138114,10 @@ function collectTemporaries(instr, env, sidemap) {
     }
     case "PropertyLoad": {
       if (sidemap.react.has(value.object.identifier.id)) {
-        if (value.property === "useMemo" || value.property === "useCallback") {
+        const property = value.property;
+        if (property === "useMemo" || property === "useCallback") {
           sidemap.manualMemos.set(instr.lvalue.identifier.id, {
-            kind: value.property,
+            kind: property,
             loadInstr: instr
           });
         }
@@ -139102,7 +138889,7 @@ function instructionReordering(fn) {
   });
   markInstructionIds(fn.body);
 }
-var DEBUG2 = false;
+var DEBUG3 = false;
 function findReferencedRangeOfTemporaries(fn) {
   const singleUseIdentifiers = /* @__PURE__ */ new Map();
   const lastAssignments = /* @__PURE__ */ new Map();
@@ -139204,16 +138991,16 @@ function reorderBlock(env, block, shared, references) {
   }
   const nextInstructions = [];
   const seen = /* @__PURE__ */ new Set();
-  DEBUG2 && console.log(`bb${block.id}`);
+  DEBUG3 && console.log(`bb${block.id}`);
   if (isExpressionBlockKind(block.kind)) {
     if (previous !== null) {
-      DEBUG2 && console.log(`(last non-reorderable instruction)`);
-      DEBUG2 && print(env, locals, shared, seen, previous);
+      DEBUG3 && console.log(`(last non-reorderable instruction)`);
+      DEBUG3 && print(env, locals, shared, seen, previous);
       emit(env, locals, shared, nextInstructions, previous);
     }
     if (block.instructions.length !== 0) {
-      DEBUG2 && console.log(`(block value)`);
-      DEBUG2 && print(
+      DEBUG3 && console.log(`(block value)`);
+      DEBUG3 && print(
         env,
         locals,
         shared,
@@ -139229,8 +139016,8 @@ function reorderBlock(env, block, shared, references) {
       );
     }
     for (const operand of eachTerminalOperand(block.terminal)) {
-      DEBUG2 && console.log(`(terminal operand)`);
-      DEBUG2 && print(env, locals, shared, seen, operand.identifier.id);
+      DEBUG3 && console.log(`(terminal operand)`);
+      DEBUG3 && print(env, locals, shared, seen, operand.identifier.id);
       emit(env, locals, shared, nextInstructions, operand.identifier.id);
     }
     for (const [id, node] of locals) {
@@ -139245,13 +139032,13 @@ function reorderBlock(env, block, shared, references) {
           description: node.instruction != null ? `Instruction [${node.instruction.id}] was not emitted yet but is not reorderable` : `Lvalue $${id} was not emitted yet but is not reorderable`
         }
       );
-      DEBUG2 && console.log(`save shared: $${id}`);
+      DEBUG3 && console.log(`save shared: $${id}`);
       shared.set(id, node);
     }
   } else {
     for (const operand of eachTerminalOperand(block.terminal)) {
-      DEBUG2 && console.log(`(terminal operand)`);
-      DEBUG2 && print(env, locals, shared, seen, operand.identifier.id);
+      DEBUG3 && console.log(`(terminal operand)`);
+      DEBUG3 && print(env, locals, shared, seen, operand.identifier.id);
       emit(env, locals, shared, nextInstructions, operand.identifier.id);
     }
     for (const id of Array.from(locals.keys()).reverse()) {
@@ -139260,17 +139047,17 @@ function reorderBlock(env, block, shared, references) {
         continue;
       }
       if (node.reorderability === 0 /* Reorderable */) {
-        DEBUG2 && console.log(`save shared: $${id}`);
+        DEBUG3 && console.log(`save shared: $${id}`);
         shared.set(id, node);
       } else {
-        DEBUG2 && console.log("leftover");
-        DEBUG2 && print(env, locals, shared, seen, id);
+        DEBUG3 && console.log("leftover");
+        DEBUG3 && print(env, locals, shared, seen, id);
         emit(env, locals, shared, nextInstructions, id);
       }
     }
   }
   block.instructions = nextInstructions;
-  DEBUG2 && console.log();
+  DEBUG3 && console.log();
 }
 function getDepth(env, nodes, id) {
   const node = nodes.get(id);
@@ -139290,7 +139077,7 @@ function getDepth(env, nodes, id) {
 }
 function print(env, locals, shared, seen, id, depth = 0) {
   if (seen.has(id)) {
-    DEBUG2 && console.log(`${"|   ".repeat(depth)}$${id} <skipped>`);
+    DEBUG3 && console.log(`${"|   ".repeat(depth)}$${id} <skipped>`);
     return;
   }
   seen.add(id);
@@ -139307,7 +139094,7 @@ function print(env, locals, shared, seen, id, depth = 0) {
   for (const dep of deps) {
     print(env, locals, shared, seen, dep, depth + 1);
   }
-  DEBUG2 && console.log(
+  DEBUG3 && console.log(
     `${"|   ".repeat(depth)}$${id} ${printNode(node)} deps=[${deps.map((x) => `$${x}`).join(", ")}] depth=${node.depth}`
   );
 }
@@ -140148,7 +139935,7 @@ function* generateInstructionTypes(env, names, instr) {
               kind: "Property",
               objectType: value.value.identifier.type,
               objectName: getName(names, value.value.identifier.id),
-              propertyName
+              propertyName: makePropertyLiteral(propertyName)
             });
           } else {
             break;
@@ -140162,7 +139949,7 @@ function* generateInstructionTypes(env, names, instr) {
                 kind: "Property",
                 objectType: value.value.identifier.type,
                 objectName: getName(names, value.value.identifier.id),
-                propertyName: property.key.name
+                propertyName: makePropertyLiteral(property.key.name)
               });
             }
           }
@@ -140249,10 +140036,12 @@ var Unifier = class {
         return;
       }
       const objectType2 = this.get(tB.objectType);
-      const propertyType = this.env.getPropertyType(
-        objectType2,
-        tB.propertyName
-      );
+      let propertyType;
+      if (typeof tB.propertyName === "number") {
+        propertyType = null;
+      } else {
+        propertyType = this.env.getPropertyType(objectType2, tB.propertyName);
+      }
       if (propertyType !== null) {
         this.unify(tA, propertyType);
       }
@@ -140687,7 +140476,7 @@ function validateHooksUsage(fn) {
         }
         case "PropertyLoad": {
           const objectKind = getKindForPlace(instr.value.object);
-          const isHookProperty = isHookName(instr.value.property);
+          const isHookProperty = typeof instr.value.property === "string" && isHookName(instr.value.property);
           let kind;
           switch (objectKind) {
             case "Error" /* Error */: {
@@ -140939,7 +140728,7 @@ function validateNoCapitalizedCalls(fn) {
           break;
         }
         case "PropertyLoad": {
-          if (/^[A-Z]/.test(value.property)) {
+          if (typeof value.property === "string" && /^[A-Z]/.test(value.property)) {
             capitalizedProperties.set(lvalue.identifier.id, value.property);
           }
           break;
@@ -141147,7 +140936,7 @@ function validateNoRefAccessInRenderImpl(fn, env) {
           }
           case "ComputedLoad":
           case "PropertyLoad": {
-            if (typeof instr.value.property !== "string") {
+            if (instr.value.kind === "ComputedLoad") {
               validateNoDirectRefValueAccess(errors, instr.value.property, env);
             }
             const objType = env.get(instr.value.object.identifier.id);
@@ -141553,7 +141342,7 @@ function validatePreservedManualMemoization(fn) {
     throw state.errors;
   }
 }
-var DEBUG3 = false;
+var DEBUG4 = false;
 function prettyPrintScopeDependency(val) {
   let rootStr;
   if (val.identifier.name?.kind === "named") {
@@ -141652,7 +141441,7 @@ function validateInferredDep(dep, temporaries, declsWithinMemoBlock, validDepsIn
   errorState.push({
     severity: "CannotPreserveMemoization" /* CannotPreserveMemoization */,
     reason: "React Compiler has skipped optimizing this component because the existing manual memoization could not be preserved. The inferred dependencies did not match the manually specified dependencies, which could cause the value to change more or less frequently than expected",
-    description: DEBUG3 ? `The inferred dependency was \`${prettyPrintScopeDependency(
+    description: DEBUG4 ? `The inferred dependency was \`${prettyPrintScopeDependency(
       dep
     )}\`, but the source dependencies were [${validDepsInMemoBlock.map((dep2) => printManualMemoDependency(dep2, true)).join(", ")}]. Detail: ${errorDiagnostic ? getCompareDependencyResultDescription(errorDiagnostic) : "none"}` : null,
     loc: memoLocation,
@@ -141692,12 +141481,6 @@ var Visitor11 = class extends ReactiveFunctionVisitor {
       case "OptionalExpression": {
         return this.recordDepsInValue(value.value, state);
       }
-      case "ReactiveFunctionValue": {
-        CompilerError.throwTodo({
-          reason: "Handle ReactiveFunctionValue in ValidatePreserveManualMemoization",
-          loc: value.loc
-        });
-      }
       case "ConditionalExpression": {
         this.recordDepsInValue(value.test, state);
         this.recordDepsInValue(value.consequent, state);
@@ -141854,7 +141637,7 @@ var Visitor11 = class extends ReactiveFunctionVisitor {
             if (isUnmemoized2(identifier5, this.scopes)) {
               state.errors.push({
                 reason: "React Compiler has skipped optimizing this component because the existing manual memoization could not be preserved. This value was memoized in source but not in compilation output.",
-                description: DEBUG3 ? `${printIdentifier(identifier5)} was not memoized` : null,
+                description: DEBUG4 ? `${printIdentifier(identifier5)} was not memoized` : null,
                 severity: "CannotPreserveMemoization" /* CannotPreserveMemoization */,
                 loc,
                 suggestions: null
@@ -142105,7 +141888,7 @@ function outlineFunctions(fn, fbtOperands) {
       if (value.kind === "FunctionExpression" || value.kind === "ObjectMethod") {
         outlineFunctions(value.loweredFunc.func, fbtOperands);
       }
-      if (value.kind === "FunctionExpression" && value.loweredFunc.dependencies.length === 0 && value.loweredFunc.func.context.length === 0 && // TODO: handle outlining named functions
+      if (value.kind === "FunctionExpression" && value.loweredFunc.func.context.length === 0 && // TODO: handle outlining named functions
       value.loweredFunc.func.id === null && !fbtOperands.has(lvalue.identifier.id)) {
         const loweredFunc = value.loweredFunc.func;
         const id = fn.env.generateGloballyUniqueIdentifierName(loweredFunc.id);
@@ -142277,7 +142060,7 @@ function emitPropertyLoad(env, obj, property) {
   const loadProp = {
     kind: "PropertyLoad",
     object,
-    property,
+    property: makePropertyLiteral(property),
     loc: GeneratedSource
   };
   const element = createTemporaryPlace(env, GeneratedSource);
@@ -142345,8 +142128,7 @@ function emitSelectorFn(env, keys) {
       kind: "FunctionExpression",
       name: null,
       loweredFunc: {
-        func: fn,
-        dependencies: []
+        func: fn
       },
       type: "ArrowFunctionExpression",
       loc: GeneratedSource
@@ -142535,14 +142317,7 @@ function collectHoistablePropertyLoads(fn, temporaries, hoistableFromOptionals)
   });
 }
 function collectHoistablePropertyLoadsImpl(fn, context) {
-  const functionExpressionLoads = collectFunctionExpressionFakeLoads(fn);
-  const actuallyEvaluatedTemporaries = new Map(
-    [...context.temporaries].filter(([id]) => !functionExpressionLoads.has(id))
-  );
-  const nodes = collectNonNullsInBlocks(fn, {
-    ...context,
-    temporaries: actuallyEvaluatedTemporaries
-  });
+  const nodes = collectNonNullsInBlocks(fn, context);
   propagateNonNull(fn, nodes, context.registry);
   if (DEBUG_PRINT) {
     console.log("(printing hoistable nodes in blocks)");
@@ -142818,26 +142593,6 @@ function reduceMaybeOptionalChains(nodes, registry) {
     }
   } while (changed);
 }
-function collectFunctionExpressionFakeLoads(fn) {
-  const sources = /* @__PURE__ */ new Map();
-  const functionExpressionReferences = /* @__PURE__ */ new Set();
-  for (const [_, block] of fn.body.blocks) {
-    for (const { lvalue, value } of block.instructions) {
-      if (value.kind === "FunctionExpression" || value.kind === "ObjectMethod") {
-        for (const reference of value.loweredFunc.dependencies) {
-          let curr = reference.identifier.id;
-          while (curr != null) {
-            functionExpressionReferences.add(curr);
-            curr = sources.get(curr);
-          }
-        }
-      } else if (value.kind === "PropertyLoad") {
-        sources.set(lvalue.identifier.id, value.object.identifier.id);
-      }
-    }
-  }
-  return functionExpressionReferences;
-}
 
 // src/Utils/Stack.ts
 function empty() {
@@ -143706,7 +143461,7 @@ function collectDependencies(fn, usedOutsideDeclaringScope, temporaries, process
         }
       }
       for (const instr of block.instructions) {
-        if (fn2.env.config.enableFunctionDependencyRewrite && (instr.value.kind === "FunctionExpression" || instr.value.kind === "ObjectMethod")) {
+        if (instr.value.kind === "FunctionExpression" || instr.value.kind === "ObjectMethod") {
           context.declare(instr.lvalue.identifier, {
             id: instr.id,
             scope: context.currentScope
@@ -144337,43 +144092,15 @@ function visitFunctionExpressionAndPropagateFireDependencies(fnExpr, context, en
   const calleesCapturedByFnExpression = withScope(
     () => replaceFireFunctions(fnExpr.loweredFunc.func, context)
   );
-  const loadLocalsToDepLoads = /* @__PURE__ */ 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 = /* @__PURE__ */ 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: "Invariant" /* Invariant */,
-        reason: "[InsertFire] No loadLocal found for fire call argument for lambda",
-        suggestions: null
-      });
-      continue;
-    }
-    const oldPlaceId = loadLocal.place.identifier.id;
-    loadLocal.place = {
-      ...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);
+    const replacedCallee = calleesCapturedByFnExpression.get(
+      contextItem.identifier.id
+    );
     if (replacedCallee != null) {
-      fnExpr.loweredFunc.func.context[contextIdx] = replacedCallee;
+      fnExpr.loweredFunc.func.context[contextIdx] = {
+        ...replacedCallee.fireFunctionBinding
+      };
     }
   }
   context.mergeCalleesFromInnerScope(calleesCapturedByFnExpression);