babel-plugin-react-compiler 0.0.0-experimental-27e0f40-20241002 → 0.0.0-experimental-7779988-20241007

package/dist/index.js

@@ -134442,7 +134442,7 @@ function installTypeConfig(globals, shapes, typeConfig, moduleName, loc) {
     }
   }
 }
-function installReAnimatedTypes(globals, registry) {
+function getReanimatedModuleType(registry) {
   const frozenHooks = [
     'useFrameCallback',
     'useAnimatedStyle',
@@ -134451,8 +134451,9 @@ function installReAnimatedTypes(globals, registry) {
     'useAnimatedReaction',
     'useWorkletCallback',
   ];
+  const reanimatedType = [];
   for (const hook of frozenHooks) {
-    globals.set(
+    reanimatedType.push([
       hook,
       addHook(registry, {
         positionalParams: [],
@@ -134462,12 +134463,12 @@ function installReAnimatedTypes(globals, registry) {
         noAlias: true,
         calleeEffect: exports.Effect.Read,
         hookKind: 'Custom',
-      })
-    );
+      }),
+    ]);
   }
   const mutableHooks = ['useSharedValue', 'useDerivedValue'];
   for (const hook of mutableHooks) {
-    globals.set(
+    reanimatedType.push([
       hook,
       addHook(registry, {
         positionalParams: [],
@@ -134477,8 +134478,8 @@ function installReAnimatedTypes(globals, registry) {
         noAlias: true,
         calleeEffect: exports.Effect.Read,
         hookKind: 'Custom',
-      })
-    );
+      }),
+    ]);
   }
   const funcs = [
     'withTiming',
@@ -134490,7 +134491,7 @@ function installReAnimatedTypes(globals, registry) {
     'executeOnUIRuntimeSync',
   ];
   for (const fn of funcs) {
-    globals.set(
+    reanimatedType.push([
       fn,
       addFunction(registry, [], {
         positionalParams: [],
@@ -134499,9 +134500,10 @@ function installReAnimatedTypes(globals, registry) {
         calleeEffect: exports.Effect.Read,
         returnValueKind: exports.ValueKind.Mutable,
         noAlias: true,
-      })
-    );
+      }),
+    ]);
   }
+  return addObject(registry, null, reanimatedType);
 }
 const ObjectPropertiesSchema = z
   .record(
@@ -134790,10 +134792,13 @@ class Environment {
       );
     }
     if (config.enableCustomTypeDefinitionForReanimated) {
-      installReAnimatedTypes(
-        __classPrivateFieldGet(this, _Environment_globals, 'f'),
+      const reanimatedModuleType = getReanimatedModuleType(
         __classPrivateFieldGet(this, _Environment_shapes, 'f')
       );
+      __classPrivateFieldGet(this, _Environment_moduleTypes, 'f').set(
+        REANIMATED_MODULE_NAME,
+        reanimatedModuleType
+      );
     }
     __classPrivateFieldSet(
       this,
@@ -135141,15 +135146,15 @@ class Environment {
     moduleName,
     loc
   ) {
-    if (this.config.moduleTypeProvider == null) {
-      return null;
-    }
     let moduleType = __classPrivateFieldGet(
       this,
       _Environment_moduleTypes,
       'f'
     ).get(moduleName);
     if (moduleType === undefined) {
+      if (this.config.moduleTypeProvider == null) {
+        return null;
+      }
       const unparsedModuleConfig = this.config.moduleTypeProvider(moduleName);
       if (unparsedModuleConfig != null) {
         const parsedModuleConfig = TypeSchema.safeParse(unparsedModuleConfig);
@@ -135193,6 +135198,7 @@ class Environment {
       return DefaultMutatingHook;
     }
   });
+const REANIMATED_MODULE_NAME = 'react-native-reanimated';
 function isHookName$1(name) {
   return /^use[A-Z0-9]/.test(name);
 }
@@ -137676,6 +137682,7 @@ function addMemoCacheFunctionImportDeclaration(program, moduleName, localName) {
   );
 }
 z.enum(['all_errors', 'critical_errors', 'none']);
+const CompilerReactTargetSchema = z.enum(['17', '18', '19']);
 z.enum(['infer', 'syntax', 'annotation', 'all']);
 const defaultOptions = {
   compilationMode: 'infer',
@@ -137684,12 +137691,12 @@ const defaultOptions = {
   logger: null,
   gating: null,
   noEmit: false,
-  runtimeModule: null,
   eslintSuppressionRules: null,
   flowSuppressions: true,
   ignoreUseNoForget: false,
   sources: filename => filename.indexOf('node_modules') === -1,
   enableReanimatedCheck: true,
+  target: '19',
 };
 function parsePluginOptions(obj) {
   if (obj == null || typeof obj !== 'object') {
@@ -137700,24 +137707,47 @@ function parsePluginOptions(obj) {
     if (typeof value === 'string') {
       value = value.toLowerCase();
     }
-    if (key === 'environment') {
-      const environmentResult = parseEnvironmentConfig(value);
-      if (environmentResult.isErr()) {
-        CompilerError.throwInvalidConfig({
-          reason:
-            'Error in validating environment config. This is an advanced setting and not meant to be used directly',
-          description: environmentResult.unwrapErr().toString(),
-          suggestions: null,
-          loc: null,
-        });
+    if (isCompilerFlag(key)) {
+      switch (key) {
+        case 'environment': {
+          const environmentResult = parseEnvironmentConfig(value);
+          if (environmentResult.isErr()) {
+            CompilerError.throwInvalidConfig({
+              reason:
+                'Error in validating environment config. This is an advanced setting and not meant to be used directly',
+              description: environmentResult.unwrapErr().toString(),
+              suggestions: null,
+              loc: null,
+            });
+          }
+          parsedOptions[key] = environmentResult.unwrap();
+          break;
+        }
+        case 'target': {
+          parsedOptions[key] = parseTargetConfig(value);
+          break;
+        }
+        default: {
+          parsedOptions[key] = value;
+        }
       }
-      parsedOptions[key] = environmentResult.unwrap();
-    } else if (isCompilerFlag(key)) {
-      parsedOptions[key] = value;
     }
   }
   return Object.assign(Object.assign({}, defaultOptions), parsedOptions);
 }
+function parseTargetConfig(value) {
+  const parsed = CompilerReactTargetSchema.safeParse(value);
+  if (parsed.success) {
+    return parsed.data;
+  } else {
+    CompilerError.throwInvalidConfig({
+      reason: 'Not a valid target',
+      description: `${fromZodError(parsed.error)}`,
+      suggestions: null,
+      loc: null,
+    });
+  }
+}
 function isCompilerFlag(s) {
   return hasOwnProperty$1(defaultOptions, s);
 }
@@ -154239,29 +154269,232 @@ function validateNoJSXInTryStatement(fn) {
     throw errors;
   }
 }
+function collectOptionalChainSidemap(fn) {
+  const context = {
+    blocks: fn.body.blocks,
+    seenOptionals: new Set(),
+    processedInstrsInOptional: new Set(),
+    temporariesReadInOptional: new Map(),
+    hoistableObjects: new Map(),
+  };
+  for (const [_, block] of fn.body.blocks) {
+    if (
+      block.terminal.kind === 'optional' &&
+      !context.seenOptionals.has(block.id)
+    ) {
+      traverseOptionalBlock(block, context, null);
+    }
+  }
+  return {
+    temporariesReadInOptional: context.temporariesReadInOptional,
+    processedInstrsInOptional: context.processedInstrsInOptional,
+    hoistableObjects: context.hoistableObjects,
+  };
+}
+function matchOptionalTestBlock(terminal, blocks) {
+  const consequentBlock = assertNonNull(blocks.get(terminal.consequent));
+  if (
+    consequentBlock.instructions.length === 2 &&
+    consequentBlock.instructions[0].value.kind === 'PropertyLoad' &&
+    consequentBlock.instructions[1].value.kind === 'StoreLocal'
+  ) {
+    const propertyLoad = consequentBlock.instructions[0];
+    const storeLocal = consequentBlock.instructions[1].value;
+    const storeLocalInstrId = consequentBlock.instructions[1].id;
+    CompilerError.invariant(
+      propertyLoad.value.object.identifier.id === terminal.test.identifier.id,
+      {
+        reason:
+          '[OptionalChainDeps] Inconsistent optional chaining property load',
+        description: `Test=${printIdentifier(terminal.test.identifier)} PropertyLoad base=${printIdentifier(propertyLoad.value.object.identifier)}`,
+        loc: propertyLoad.loc,
+      }
+    );
+    CompilerError.invariant(
+      storeLocal.value.identifier.id === propertyLoad.lvalue.identifier.id,
+      {
+        reason: '[OptionalChainDeps] Unexpected storeLocal',
+        loc: propertyLoad.loc,
+      }
+    );
+    if (
+      consequentBlock.terminal.kind !== 'goto' ||
+      consequentBlock.terminal.variant !== GotoVariant.Break
+    ) {
+      return null;
+    }
+    const alternate = assertNonNull(blocks.get(terminal.alternate));
+    CompilerError.invariant(
+      alternate.instructions.length === 2 &&
+        alternate.instructions[0].value.kind === 'Primitive' &&
+        alternate.instructions[1].value.kind === 'StoreLocal',
+      {reason: 'Unexpected alternate structure', loc: terminal.loc}
+    );
+    return {
+      consequentId: storeLocal.lvalue.place.identifier.id,
+      property: propertyLoad.value.property,
+      propertyId: propertyLoad.lvalue.identifier.id,
+      storeLocalInstrId: storeLocalInstrId,
+      consequentGoto: consequentBlock.terminal.block,
+    };
+  }
+  return null;
+}
+function traverseOptionalBlock(optional, context, outerAlternate) {
+  context.seenOptionals.add(optional.id);
+  const maybeTest = context.blocks.get(optional.terminal.test);
+  let test;
+  let baseObject;
+  if (maybeTest.terminal.kind === 'branch') {
+    CompilerError.invariant(optional.terminal.optional, {
+      reason: '[OptionalChainDeps] Expect base case to be always optional',
+      loc: optional.terminal.loc,
+    });
+    if (
+      maybeTest.instructions.length === 0 ||
+      maybeTest.instructions[0].value.kind !== 'LoadLocal'
+    ) {
+      return null;
+    }
+    const path = [];
+    for (let i = 1; i < maybeTest.instructions.length; i++) {
+      const instrVal = maybeTest.instructions[i].value;
+      const prevInstr = maybeTest.instructions[i - 1];
+      if (
+        instrVal.kind === 'PropertyLoad' &&
+        instrVal.object.identifier.id === prevInstr.lvalue.identifier.id
+      ) {
+        path.push({property: instrVal.property, optional: false});
+      } else {
+        return null;
+      }
+    }
+    CompilerError.invariant(
+      maybeTest.terminal.test.identifier.id ===
+        maybeTest.instructions.at(-1).lvalue.identifier.id,
+      {
+        reason: '[OptionalChainDeps] Unexpected test expression',
+        loc: maybeTest.terminal.loc,
+      }
+    );
+    baseObject = {
+      identifier: maybeTest.instructions[0].value.place.identifier,
+      path: path,
+    };
+    test = maybeTest.terminal;
+  } else if (maybeTest.terminal.kind === 'optional') {
+    const testBlock = context.blocks.get(maybeTest.terminal.fallthrough);
+    if (testBlock.terminal.kind !== 'branch') {
+      CompilerError.throwTodo({
+        reason: `Unexpected terminal kind \`${testBlock.terminal.kind}\` for optional fallthrough block`,
+        loc: maybeTest.terminal.loc,
+      });
+    }
+    const innerOptional = traverseOptionalBlock(
+      maybeTest,
+      context,
+      testBlock.terminal.alternate
+    );
+    if (innerOptional == null) {
+      return null;
+    }
+    if (testBlock.terminal.test.identifier.id !== innerOptional) {
+      return null;
+    }
+    if (!optional.terminal.optional) {
+      context.hoistableObjects.set(
+        optional.id,
+        assertNonNull(context.temporariesReadInOptional.get(innerOptional))
+      );
+    }
+    baseObject = assertNonNull(
+      context.temporariesReadInOptional.get(innerOptional)
+    );
+    test = testBlock.terminal;
+  } else {
+    return null;
+  }
+  if (test.alternate === outerAlternate) {
+    CompilerError.invariant(optional.instructions.length === 0, {
+      reason:
+        '[OptionalChainDeps] Unexpected instructions an inner optional block. ' +
+        'This indicates that the compiler may be incorrectly concatenating two unrelated optional chains',
+      loc: optional.terminal.loc,
+    });
+  }
+  const matchConsequentResult = matchOptionalTestBlock(test, context.blocks);
+  if (!matchConsequentResult) {
+    return null;
+  }
+  CompilerError.invariant(
+    matchConsequentResult.consequentGoto === optional.terminal.fallthrough,
+    {
+      reason: '[OptionalChainDeps] Unexpected optional goto-fallthrough',
+      description: `${matchConsequentResult.consequentGoto} != ${optional.terminal.fallthrough}`,
+      loc: optional.terminal.loc,
+    }
+  );
+  const load = {
+    identifier: baseObject.identifier,
+    path: [
+      ...baseObject.path,
+      {
+        property: matchConsequentResult.property,
+        optional: optional.terminal.optional,
+      },
+    ],
+  };
+  context.processedInstrsInOptional.add(
+    matchConsequentResult.storeLocalInstrId
+  );
+  context.processedInstrsInOptional.add(test.id);
+  context.temporariesReadInOptional.set(
+    matchConsequentResult.consequentId,
+    load
+  );
+  context.temporariesReadInOptional.set(matchConsequentResult.propertyId, load);
+  return matchConsequentResult.consequentId;
+}
 function collectHoistablePropertyLoads(
   fn,
   temporaries,
-  hoistableFromOptionals
+  hoistableFromOptionals,
+  nestedFnImmutableContext
 ) {
   const registry = new PropertyPathRegistry();
-  const nodes = collectNonNullsInBlocks(
-    fn,
-    temporaries,
-    hoistableFromOptionals,
-    registry
+  const functionExpressionLoads = collectFunctionExpressionFakeLoads(fn);
+  const actuallyEvaluatedTemporaries = new Map(
+    [...temporaries].filter(([id]) => !functionExpressionLoads.has(id))
   );
+  const knownImmutableIdentifiers = new Set();
+  if (fn.fnType === 'Component' || fn.fnType === 'Hook') {
+    for (const p of fn.params) {
+      if (p.kind === 'Identifier') {
+        knownImmutableIdentifiers.add(p.identifier.id);
+      }
+    }
+  }
+  const nodes = collectNonNullsInBlocks(fn, {
+    temporaries: actuallyEvaluatedTemporaries,
+    knownImmutableIdentifiers: knownImmutableIdentifiers,
+    hoistableFromOptionals: hoistableFromOptionals,
+    registry: registry,
+    nestedFnImmutableContext: nestedFnImmutableContext,
+  });
   propagateNonNull(fn, nodes, registry);
-  const nodesKeyedByScopeId = new Map();
+  return nodes;
+}
+function keyByScopeId(fn, source) {
+  const keyedByScopeId = new Map();
   for (const [_, block] of fn.body.blocks) {
     if (block.terminal.kind === 'scope') {
-      nodesKeyedByScopeId.set(
+      keyedByScopeId.set(
         block.terminal.scope.id,
-        nodes.get(block.terminal.block)
+        source.get(block.terminal.block)
       );
     }
   }
-  return nodesKeyedByScopeId;
+  return keyedByScopeId;
 }
 class PropertyPathRegistry {
   constructor() {
@@ -154317,39 +154550,45 @@ class PropertyPathRegistry {
     );
   }
 }
-function addNonNullPropertyPath(
-  source,
-  sourceNode,
-  instrId,
-  knownImmutableIdentifiers,
-  result
-) {
-  const isMutableAtInstr =
-    source.mutableRange.end > source.mutableRange.start + 1 &&
-    source.scope != null &&
-    inRange({id: instrId}, source.scope.range);
-  if (
-    !isMutableAtInstr ||
-    knownImmutableIdentifiers.has(sourceNode.fullPath.identifier.id)
-  ) {
-    result.add(sourceNode);
+function getMaybeNonNullInInstruction(instr, context) {
+  var _a, _b, _c;
+  let path = null;
+  if (instr.kind === 'PropertyLoad') {
+    path =
+      (_a = context.temporaries.get(instr.object.identifier.id)) !== null &&
+      _a !== void 0
+        ? _a
+        : {identifier: instr.object.identifier, path: []};
+  } else if (instr.kind === 'Destructure') {
+    path =
+      (_b = context.temporaries.get(instr.value.identifier.id)) !== null &&
+      _b !== void 0
+        ? _b
+        : null;
+  } else if (instr.kind === 'ComputedLoad') {
+    path =
+      (_c = context.temporaries.get(instr.object.identifier.id)) !== null &&
+      _c !== void 0
+        ? _c
+        : null;
   }
+  return path != null ? context.registry.getOrCreateProperty(path) : null;
 }
-function collectNonNullsInBlocks(
-  fn,
-  temporaries,
-  hoistableFromOptionals,
-  registry
-) {
-  var _a;
-  const knownImmutableIdentifiers = new Set();
-  if (fn.fnType === 'Component' || fn.fnType === 'Hook') {
-    for (const p of fn.params) {
-      if (p.kind === 'Identifier') {
-        knownImmutableIdentifiers.add(p.identifier.id);
-      }
-    }
+function isImmutableAtInstr(identifier, instr, context) {
+  if (context.nestedFnImmutableContext != null) {
+    return context.nestedFnImmutableContext.has(identifier.id);
+  } else {
+    const mutableAtInstr =
+      identifier.mutableRange.end > identifier.mutableRange.start + 1 &&
+      identifier.scope != null &&
+      inRange({id: instr}, identifier.scope.range);
+    return (
+      !mutableAtInstr || context.knownImmutableIdentifiers.has(identifier.id)
+    );
   }
+}
+function collectNonNullsInBlocks(fn, context) {
+  var _a;
   const knownNonNullIdentifiers = new Set();
   if (
     fn.fnType === 'Component' &&
@@ -154357,54 +154596,56 @@ function collectNonNullsInBlocks(
     fn.params[0].kind === 'Identifier'
   ) {
     const identifier = fn.params[0].identifier;
-    knownNonNullIdentifiers.add(registry.getOrCreateIdentifier(identifier));
+    knownNonNullIdentifiers.add(
+      context.registry.getOrCreateIdentifier(identifier)
+    );
   }
   const nodes = new Map();
   for (const [_, block] of fn.body.blocks) {
     const assumedNonNullObjects = new Set(knownNonNullIdentifiers);
-    const maybeOptionalChain = hoistableFromOptionals.get(block.id);
+    const maybeOptionalChain = context.hoistableFromOptionals.get(block.id);
     if (maybeOptionalChain != null) {
       assumedNonNullObjects.add(
-        registry.getOrCreateProperty(maybeOptionalChain)
+        context.registry.getOrCreateProperty(maybeOptionalChain)
       );
     }
     for (const instr of block.instructions) {
-      if (instr.value.kind === 'PropertyLoad') {
-        const source =
-          (_a = temporaries.get(instr.value.object.identifier.id)) !== null &&
-          _a !== void 0
+      const maybeNonNull = getMaybeNonNullInInstruction(instr.value, context);
+      if (
+        maybeNonNull != null &&
+        isImmutableAtInstr(maybeNonNull.fullPath.identifier, instr.id, context)
+      ) {
+        assumedNonNullObjects.add(maybeNonNull);
+      }
+      if (
+        instr.value.kind === 'FunctionExpression' &&
+        !fn.env.config.enableTreatFunctionDepsAsConditional
+      ) {
+        const innerFn = instr.value.loweredFunc;
+        const innerTemporaries = collectTemporariesSidemap(
+          innerFn.func,
+          new Set()
+        );
+        const innerOptionals = collectOptionalChainSidemap(innerFn.func);
+        const innerHoistableMap = collectHoistablePropertyLoads(
+          innerFn.func,
+          innerTemporaries,
+          innerOptionals.hoistableObjects,
+          (_a = context.nestedFnImmutableContext) !== null && _a !== void 0
             ? _a
-            : {identifier: instr.value.object.identifier, path: []};
-        addNonNullPropertyPath(
-          instr.value.object.identifier,
-          registry.getOrCreateProperty(source),
-          instr.id,
-          knownImmutableIdentifiers,
-          assumedNonNullObjects
+            : new Set(
+                innerFn.func.context
+                  .filter(place =>
+                    isImmutableAtInstr(place.identifier, instr.id, context)
+                  )
+                  .map(place => place.identifier.id)
+              )
         );
-      } else if (instr.value.kind === 'Destructure') {
-        const source = instr.value.value.identifier.id;
-        const sourceNode = temporaries.get(source);
-        if (sourceNode != null) {
-          addNonNullPropertyPath(
-            instr.value.value.identifier,
-            registry.getOrCreateProperty(sourceNode),
-            instr.id,
-            knownImmutableIdentifiers,
-            assumedNonNullObjects
-          );
-        }
-      } else if (instr.value.kind === 'ComputedLoad') {
-        const source = instr.value.object.identifier.id;
-        const sourceNode = temporaries.get(source);
-        if (sourceNode != null) {
-          addNonNullPropertyPath(
-            instr.value.object.identifier,
-            registry.getOrCreateProperty(sourceNode),
-            instr.id,
-            knownImmutableIdentifiers,
-            assumedNonNullObjects
-          );
+        const innerHoistables = assertNonNull(
+          innerHoistableMap.get(innerFn.func.body.entry)
+        );
+        for (const entry of innerHoistables.assumedNonNullObjects) {
+          assumedNonNullObjects.add(entry);
         }
       }
     }
@@ -154542,6 +154783,26 @@ function reduceMaybeOptionalChains(nodes, registry) {
     }
   } while (changed);
 }
+function collectFunctionExpressionFakeLoads(fn) {
+  const sources = new Map();
+  const functionExpressionReferences = new Set();
+  for (const [_, block] of fn.body.blocks) {
+    for (const {lvalue: lvalue, value: value} of block.instructions) {
+      if (value.kind === 'FunctionExpression') {
+        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;
+}
 var _a,
   _ReactiveScopeDependencyTreeHIR_hoistableObjects,
   _ReactiveScopeDependencyTreeHIR_deps,
@@ -154801,192 +155062,6 @@ function makeOrMergeProperty(node, property, accessType) {
   }
   return child;
 }
-function collectOptionalChainSidemap(fn) {
-  const context = {
-    blocks: fn.body.blocks,
-    seenOptionals: new Set(),
-    processedInstrsInOptional: new Set(),
-    temporariesReadInOptional: new Map(),
-    hoistableObjects: new Map(),
-  };
-  for (const [_, block] of fn.body.blocks) {
-    if (
-      block.terminal.kind === 'optional' &&
-      !context.seenOptionals.has(block.id)
-    ) {
-      traverseOptionalBlock(block, context, null);
-    }
-  }
-  return {
-    temporariesReadInOptional: context.temporariesReadInOptional,
-    processedInstrsInOptional: context.processedInstrsInOptional,
-    hoistableObjects: context.hoistableObjects,
-  };
-}
-function matchOptionalTestBlock(terminal, blocks) {
-  const consequentBlock = assertNonNull(blocks.get(terminal.consequent));
-  if (
-    consequentBlock.instructions.length === 2 &&
-    consequentBlock.instructions[0].value.kind === 'PropertyLoad' &&
-    consequentBlock.instructions[1].value.kind === 'StoreLocal'
-  ) {
-    const propertyLoad = consequentBlock.instructions[0];
-    const storeLocal = consequentBlock.instructions[1].value;
-    const storeLocalInstrId = consequentBlock.instructions[1].id;
-    CompilerError.invariant(
-      propertyLoad.value.object.identifier.id === terminal.test.identifier.id,
-      {
-        reason:
-          '[OptionalChainDeps] Inconsistent optional chaining property load',
-        description: `Test=${printIdentifier(terminal.test.identifier)} PropertyLoad base=${printIdentifier(propertyLoad.value.object.identifier)}`,
-        loc: propertyLoad.loc,
-      }
-    );
-    CompilerError.invariant(
-      storeLocal.value.identifier.id === propertyLoad.lvalue.identifier.id,
-      {
-        reason: '[OptionalChainDeps] Unexpected storeLocal',
-        loc: propertyLoad.loc,
-      }
-    );
-    if (
-      consequentBlock.terminal.kind !== 'goto' ||
-      consequentBlock.terminal.variant !== GotoVariant.Break
-    ) {
-      return null;
-    }
-    const alternate = assertNonNull(blocks.get(terminal.alternate));
-    CompilerError.invariant(
-      alternate.instructions.length === 2 &&
-        alternate.instructions[0].value.kind === 'Primitive' &&
-        alternate.instructions[1].value.kind === 'StoreLocal',
-      {reason: 'Unexpected alternate structure', loc: terminal.loc}
-    );
-    return {
-      consequentId: storeLocal.lvalue.place.identifier.id,
-      property: propertyLoad.value.property,
-      propertyId: propertyLoad.lvalue.identifier.id,
-      storeLocalInstrId: storeLocalInstrId,
-      consequentGoto: consequentBlock.terminal.block,
-    };
-  }
-  return null;
-}
-function traverseOptionalBlock(optional, context, outerAlternate) {
-  context.seenOptionals.add(optional.id);
-  const maybeTest = context.blocks.get(optional.terminal.test);
-  let test;
-  let baseObject;
-  if (maybeTest.terminal.kind === 'branch') {
-    CompilerError.invariant(optional.terminal.optional, {
-      reason: '[OptionalChainDeps] Expect base case to be always optional',
-      loc: optional.terminal.loc,
-    });
-    if (
-      maybeTest.instructions.length === 0 ||
-      maybeTest.instructions[0].value.kind !== 'LoadLocal'
-    ) {
-      return null;
-    }
-    const path = [];
-    for (let i = 1; i < maybeTest.instructions.length; i++) {
-      const instrVal = maybeTest.instructions[i].value;
-      const prevInstr = maybeTest.instructions[i - 1];
-      if (
-        instrVal.kind === 'PropertyLoad' &&
-        instrVal.object.identifier.id === prevInstr.lvalue.identifier.id
-      ) {
-        path.push({property: instrVal.property, optional: false});
-      } else {
-        return null;
-      }
-    }
-    CompilerError.invariant(
-      maybeTest.terminal.test.identifier.id ===
-        maybeTest.instructions.at(-1).lvalue.identifier.id,
-      {
-        reason: '[OptionalChainDeps] Unexpected test expression',
-        loc: maybeTest.terminal.loc,
-      }
-    );
-    baseObject = {
-      identifier: maybeTest.instructions[0].value.place.identifier,
-      path: path,
-    };
-    test = maybeTest.terminal;
-  } else if (maybeTest.terminal.kind === 'optional') {
-    const testBlock = context.blocks.get(maybeTest.terminal.fallthrough);
-    if (testBlock.terminal.kind !== 'branch') {
-      CompilerError.throwTodo({
-        reason: `Unexpected terminal kind \`${testBlock.terminal.kind}\` for optional fallthrough block`,
-        loc: maybeTest.terminal.loc,
-      });
-    }
-    const innerOptional = traverseOptionalBlock(
-      maybeTest,
-      context,
-      testBlock.terminal.alternate
-    );
-    if (innerOptional == null) {
-      return null;
-    }
-    if (testBlock.terminal.test.identifier.id !== innerOptional) {
-      return null;
-    }
-    if (!optional.terminal.optional) {
-      context.hoistableObjects.set(
-        optional.id,
-        assertNonNull(context.temporariesReadInOptional.get(innerOptional))
-      );
-    }
-    baseObject = assertNonNull(
-      context.temporariesReadInOptional.get(innerOptional)
-    );
-    test = testBlock.terminal;
-  } else {
-    return null;
-  }
-  if (test.alternate === outerAlternate) {
-    CompilerError.invariant(optional.instructions.length === 0, {
-      reason:
-        '[OptionalChainDeps] Unexpected instructions an inner optional block. ' +
-        'This indicates that the compiler may be incorrectly concatenating two unrelated optional chains',
-      loc: optional.terminal.loc,
-    });
-  }
-  const matchConsequentResult = matchOptionalTestBlock(test, context.blocks);
-  if (!matchConsequentResult) {
-    return null;
-  }
-  CompilerError.invariant(
-    matchConsequentResult.consequentGoto === optional.terminal.fallthrough,
-    {
-      reason: '[OptionalChainDeps] Unexpected optional goto-fallthrough',
-      description: `${matchConsequentResult.consequentGoto} != ${optional.terminal.fallthrough}`,
-      loc: optional.terminal.loc,
-    }
-  );
-  const load = {
-    identifier: baseObject.identifier,
-    path: [
-      ...baseObject.path,
-      {
-        property: matchConsequentResult.property,
-        optional: optional.terminal.optional,
-      },
-    ],
-  };
-  context.processedInstrsInOptional.add(
-    matchConsequentResult.storeLocalInstrId
-  );
-  context.processedInstrsInOptional.add(test.id);
-  context.temporariesReadInOptional.set(
-    matchConsequentResult.consequentId,
-    load
-  );
-  context.temporariesReadInOptional.set(matchConsequentResult.propertyId, load);
-  return matchConsequentResult.consequentId;
-}
 var _Context_instances,
   _Context_declarations,
   _Context_reassignments,
@@ -155005,10 +155080,9 @@ function propagateScopeDependenciesHIR(fn) {
     processedInstrsInOptional: processedInstrsInOptional,
     hoistableObjects: hoistableObjects,
   } = collectOptionalChainSidemap(fn);
-  const hoistablePropertyLoads = collectHoistablePropertyLoads(
+  const hoistablePropertyLoads = keyByScopeId(
     fn,
-    temporaries,
-    hoistableObjects
+    collectHoistablePropertyLoads(fn, temporaries, hoistableObjects, null)
   );
   const scopeDeps = collectDependencies(
     fn,
@@ -156148,7 +156222,7 @@ function isFilePartOfSources(sources, filename) {
   return false;
 }
 function compileProgram(program, pass) {
-  var _a, _b, _c;
+  var _a, _b;
   if (shouldSkipCompilation(program, pass)) {
     return;
   }
@@ -156159,14 +156233,10 @@ function compileProgram(program, pass) {
     return;
   }
   const useMemoCacheIdentifier = program.scope.generateUidIdentifier('c');
-  const moduleName =
-    (_a = pass.opts.runtimeModule) !== null && _a !== void 0
-      ? _a
-      : 'react/compiler-runtime';
   const suppressions = findProgramSuppressions(
     pass.comments,
-    (_b = pass.opts.eslintSuppressionRules) !== null && _b !== void 0
-      ? _b
+    (_a = pass.opts.eslintSuppressionRules) !== null && _a !== void 0
+      ? _a
       : DEFAULT_ESLINT_SUPPRESSIONS,
     pass.opts.flowSuppressions
   );
@@ -156197,7 +156267,7 @@ function compileProgram(program, pass) {
     },
     Object.assign(Object.assign({}, pass), {
       opts: Object.assign(Object.assign({}, pass.opts), pass.opts),
-      filename: (_c = pass.filename) !== null && _c !== void 0 ? _c : null,
+      filename: (_b = pass.filename) !== null && _b !== void 0 ? _b : null,
     })
   );
   const processFn = (fn, fnType) => {
@@ -156405,7 +156475,7 @@ function compileProgram(program, pass) {
     if (needsMemoCacheFunctionImport) {
       updateMemoCacheFunctionImport(
         program,
-        moduleName,
+        getReactCompilerRuntimeModule(pass.opts),
         useMemoCacheIdentifier.name
       );
     }
@@ -156413,7 +156483,6 @@ function compileProgram(program, pass) {
   }
 }
 function shouldSkipCompilation(program, pass) {
-  var _a;
   if (pass.opts.sources) {
     if (pass.filename === null) {
       const error = new CompilerError();
@@ -156433,11 +156502,12 @@ function shouldSkipCompilation(program, pass) {
       return true;
     }
   }
-  const moduleName =
-    (_a = pass.opts.runtimeModule) !== null && _a !== void 0
-      ? _a
-      : 'react/compiler-runtime';
-  if (hasMemoCacheFunctionImport(program, moduleName)) {
+  if (
+    hasMemoCacheFunctionImport(
+      program,
+      getReactCompilerRuntimeModule(pass.opts)
+    )
+  ) {
     return true;
   }
   return false;
@@ -156778,6 +156848,28 @@ function checkFunctionReferencedBeforeDeclarationAtTopLevel(program, fns) {
   });
   return errors.details.length > 0 ? errors : null;
 }
+function getReactCompilerRuntimeModule(opts) {
+  let moduleName = null;
+  switch (opts.target) {
+    case '17':
+    case '18': {
+      moduleName = 'react-compiler-runtime';
+      break;
+    }
+    case '19': {
+      moduleName = 'react/compiler-runtime';
+      break;
+    }
+    default:
+      CompilerError.invariant(moduleName != null, {
+        reason: 'Expected target to already be validated',
+        description: null,
+        loc: null,
+        suggestions: null,
+      });
+  }
+  return moduleName;
+}
 function hasModule(name) {
   try {
     return !!require.resolve(name);