babel-plugin-react-compiler 0.0.0-experimental-b4db8c3-20241001 → 0.0.0-experimental-734b737-20241003

package/dist/index.js

@@ -119602,6 +119602,17 @@ function getOrInsertDefault(m, key, defaultValue) {
     return defaultValue;
   }
 }
+function Set_equal(a, b) {
+  if (a.size !== b.size) {
+    return false;
+  }
+  for (const item of a) {
+    if (!b.has(item)) {
+      return false;
+    }
+  }
+  return true;
+}
 function Set_union(a, b) {
   const union = new Set(a);
   for (const item of b) {
@@ -119635,6 +119646,15 @@ function Iterable_some(iter, pred) {
   }
   return false;
 }
+function Set_filter(source, fn) {
+  const result = new Set();
+  for (const entry of source) {
+    if (fn(entry)) {
+      result.add(entry);
+    }
+  }
+  return result;
+}
 function hasNode(input) {
   return input.node != null;
 }
@@ -144922,7 +144942,7 @@ class ReactiveScopeDependencyTree {
     }
     const depType = inConditional
       ? PropertyAccessType$1.ConditionalDependency
-      : isOptional(currNode.accessType)
+      : isOptional$1(currNode.accessType)
         ? PropertyAccessType$1.OptionalDependency
         : PropertyAccessType$1.UnconditionalDependency;
     currNode.accessType = merge$1(currNode.accessType, depType);
@@ -144934,7 +144954,7 @@ class ReactiveScopeDependencyTree {
       _ReactiveScopeDependencyTree_roots,
       'f'
     ).entries()) {
-      const deps = deriveMinimalDependenciesInSubtree$1(rootNode, null);
+      const deps = deriveMinimalDependenciesInSubtree(rootNode, null);
       CompilerError.invariant(
         deps.every(
           dep =>
@@ -145092,7 +145112,7 @@ var PropertyAccessType$1;
   PropertyAccessType['OptionalDependency'] = 'OptionalDependency';
   PropertyAccessType['UnconditionalDependency'] = 'UnconditionalDependency';
 })(PropertyAccessType$1 || (PropertyAccessType$1 = {}));
-const MIN_ACCESS_TYPE$1 = PropertyAccessType$1.ConditionalAccess;
+const MIN_ACCESS_TYPE = PropertyAccessType$1.ConditionalAccess;
 function isUnconditional(access) {
   return (
     access === PropertyAccessType$1.UnconditionalAccess ||
@@ -145106,7 +145126,7 @@ function isDependency$1(access) {
     access === PropertyAccessType$1.UnconditionalDependency
   );
 }
-function isOptional(access) {
+function isOptional$1(access) {
   return (
     access === PropertyAccessType$1.OptionalAccess ||
     access === PropertyAccessType$1.OptionalDependency
@@ -145116,7 +145136,7 @@ function merge$1(access1, access2) {
   const resultIsUnconditional =
     isUnconditional(access1) || isUnconditional(access2);
   const resultIsDependency = isDependency$1(access1) || isDependency$1(access2);
-  const resultIsOptional = isOptional(access1) || isOptional(access2);
+  const resultIsOptional = isOptional$1(access1) || isOptional$1(access2);
   if (resultIsUnconditional) {
     if (resultIsDependency) {
       return PropertyAccessType$1.UnconditionalDependency;
@@ -145153,10 +145173,10 @@ function prependPath(results, path) {
     relativePath: [path, ...result.relativePath],
   }));
 }
-function deriveMinimalDependenciesInSubtree$1(dep, property) {
+function deriveMinimalDependenciesInSubtree(dep, property) {
   const results = [];
   for (const [childName, childNode] of dep.properties) {
-    const childResult = deriveMinimalDependenciesInSubtree$1(
+    const childResult = deriveMinimalDependenciesInSubtree(
       childNode,
       childName
     );
@@ -145322,7 +145342,7 @@ function printSubtree$1(node, includeAccesses) {
 function getOrMakeProperty(node, property) {
   let child = node.properties.get(property);
   if (child == null) {
-    child = {properties: new Map(), accessType: MIN_ACCESS_TYPE$1};
+    child = {properties: new Map(), accessType: MIN_ACCESS_TYPE};
     node.properties.set(property, child);
   }
   return child;
@@ -154219,20 +154239,232 @@ function validateNoJSXInTryStatement(fn) {
     throw errors;
   }
 }
-function collectHoistablePropertyLoads(fn, temporaries) {
+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,
+  nestedFnImmutableContext
+) {
   const registry = new PropertyPathRegistry();
-  const nodes = collectNonNullsInBlocks(fn, temporaries, registry);
-  propagateNonNull(fn, nodes);
-  const nodesKeyedByScopeId = new Map();
+  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);
+  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() {
@@ -154244,7 +154476,9 @@ class PropertyPathRegistry {
       rootNode = {
         root: identifier.id,
         properties: new Map(),
+        optionalProperties: new Map(),
         fullPath: {identifier: identifier, path: []},
+        hasOptional: false,
         parent: null,
       };
       this.roots.set(identifier.id, rootNode);
@@ -154252,23 +154486,20 @@ class PropertyPathRegistry {
     return rootNode;
   }
   static getOrCreatePropertyEntry(parent, entry) {
-    if (entry.optional) {
-      CompilerError.throwTodo({
-        reason: 'handle optional nodes',
-        loc: GeneratedSource,
-      });
-    }
-    let child = parent.properties.get(entry.property);
+    const map = entry.optional ? parent.optionalProperties : parent.properties;
+    let child = map.get(entry.property);
     if (child == null) {
       child = {
         properties: new Map(),
+        optionalProperties: new Map(),
         parent: parent,
         fullPath: {
           identifier: parent.fullPath.identifier,
           path: parent.fullPath.path.concat(entry),
         },
+        hasOptional: parent.hasOptional || entry.optional,
       };
-      parent.properties.set(entry.property, child);
+      map.set(entry.property, child);
     }
     return child;
   }
@@ -154289,34 +154520,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, 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' &&
@@ -154324,48 +154566,56 @@ function collectNonNullsInBlocks(fn, temporaries, registry) {
     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 = context.hoistableFromOptionals.get(block.id);
+    if (maybeOptionalChain != null) {
+      assumedNonNullObjects.add(
+        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);
         }
       }
     }
@@ -154376,7 +154626,7 @@ function collectNonNullsInBlocks(fn, temporaries, registry) {
   }
   return nodes;
 }
-function propagateNonNull(fn, nodes) {
+function propagateNonNull(fn, nodes, registry) {
   const blockSuccessors = new Map();
   const terminalPreds = new Set();
   for (const [blockId, block] of fn.body.blocks) {
@@ -154425,9 +154675,10 @@ function propagateNonNull(fn, nodes) {
     );
     const prevObjects = assertNonNull(nodes.get(nodeId)).assumedNonNullObjects;
     const mergedObjects = Set_union(prevObjects, neighborAccesses);
+    reduceMaybeOptionalChains(mergedObjects, registry);
     assertNonNull(nodes.get(nodeId)).assumedNonNullObjects = mergedObjects;
     traversalState.set(nodeId, 'done');
-    changed || (changed = prevObjects.size !== mergedObjects.size);
+    changed || (changed = !Set_equal(prevObjects, mergedObjects));
     return changed;
   }
   const traversalState = new Map();
@@ -154470,70 +154721,176 @@ function assertNonNull(value, source) {
   });
   return value;
 }
-var _ReactiveScopeDependencyTreeHIR_instances,
-  _ReactiveScopeDependencyTreeHIR_roots,
-  _ReactiveScopeDependencyTreeHIR_getOrCreateRoot;
+function reduceMaybeOptionalChains(nodes, registry) {
+  let optionalChainNodes = Set_filter(nodes, n => n.hasOptional);
+  if (optionalChainNodes.size === 0) {
+    return;
+  }
+  let changed;
+  do {
+    changed = false;
+    for (const original of optionalChainNodes) {
+      let {identifier: identifier, path: origPath} = original.fullPath;
+      let currNode = registry.getOrCreateIdentifier(identifier);
+      for (let i = 0; i < origPath.length; i++) {
+        const entry = origPath[i];
+        const nextEntry =
+          entry.optional && nodes.has(currNode)
+            ? {property: entry.property, optional: false}
+            : entry;
+        currNode = PropertyPathRegistry.getOrCreatePropertyEntry(
+          currNode,
+          nextEntry
+        );
+      }
+      if (currNode !== original) {
+        changed = true;
+        optionalChainNodes.delete(original);
+        optionalChainNodes.add(currNode);
+        nodes.delete(original);
+        nodes.add(currNode);
+      }
+    }
+  } 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,
+  _ReactiveScopeDependencyTreeHIR_getOrCreateRoot,
+  _ReactiveScopeDependencyTreeHIR_debugImpl;
 class ReactiveScopeDependencyTreeHIR {
-  constructor() {
-    _ReactiveScopeDependencyTreeHIR_instances.add(this);
-    _ReactiveScopeDependencyTreeHIR_roots.set(this, new Map());
+  constructor(hoistableObjects) {
+    var _b;
+    _ReactiveScopeDependencyTreeHIR_hoistableObjects.set(this, new Map());
+    _ReactiveScopeDependencyTreeHIR_deps.set(this, new Map());
+    for (const {path: path, identifier: identifier} of hoistableObjects) {
+      let currNode = __classPrivateFieldGet(
+        _a,
+        _a,
+        'm',
+        _ReactiveScopeDependencyTreeHIR_getOrCreateRoot
+      ).call(
+        _a,
+        identifier,
+        __classPrivateFieldGet(
+          this,
+          _ReactiveScopeDependencyTreeHIR_hoistableObjects,
+          'f'
+        ),
+        path.length > 0 && path[0].optional ? 'Optional' : 'NonNull'
+      );
+      for (let i = 0; i < path.length; i++) {
+        const prevAccessType =
+          (_b = currNode.properties.get(path[i].property)) === null ||
+          _b === void 0
+            ? void 0
+            : _b.accessType;
+        const accessType =
+          i + 1 < path.length && path[i + 1].optional ? 'Optional' : 'NonNull';
+        CompilerError.invariant(
+          prevAccessType == null || prevAccessType === accessType,
+          {reason: 'Conflicting access types', loc: GeneratedSource}
+        );
+        let nextNode = currNode.properties.get(path[i].property);
+        if (nextNode == null) {
+          nextNode = {properties: new Map(), accessType: accessType};
+          currNode.properties.set(path[i].property, nextNode);
+        }
+        currNode = nextNode;
+      }
+    }
   }
   addDependency(dep) {
-    const {path: path} = dep;
-    let currNode = __classPrivateFieldGet(
-      this,
-      _ReactiveScopeDependencyTreeHIR_instances,
+    const {identifier: identifier, path: path} = dep;
+    let depCursor = __classPrivateFieldGet(
+      _a,
+      _a,
       'm',
       _ReactiveScopeDependencyTreeHIR_getOrCreateRoot
-    ).call(this, dep.identifier, MIN_ACCESS_TYPE);
-    const accessType = PropertyAccessType.Access;
-    currNode.accessType = merge(currNode.accessType, accessType);
-    for (const property of path) {
-      let currChild = makeOrMergeProperty(
-        currNode,
-        property.property,
-        accessType
-      );
-      currNode = currChild;
-    }
-    currNode.accessType = merge(
-      currNode.accessType,
-      PropertyAccessType.Dependency
+    ).call(
+      _a,
+      identifier,
+      __classPrivateFieldGet(this, _ReactiveScopeDependencyTreeHIR_deps, 'f'),
+      PropertyAccessType.UnconditionalAccess
     );
-  }
-  markNodesNonNull(dep) {
-    const accessType = PropertyAccessType.NonNullAccess;
-    let currNode = __classPrivateFieldGet(
+    let hoistableCursor = __classPrivateFieldGet(
       this,
-      _ReactiveScopeDependencyTreeHIR_roots,
+      _ReactiveScopeDependencyTreeHIR_hoistableObjects,
       'f'
-    ).get(dep.identifier);
-    let cursor = 0;
-    while (currNode != null && cursor < dep.path.length) {
-      currNode.accessType = merge(currNode.accessType, accessType);
-      currNode = currNode.properties.get(dep.path[cursor++].property);
-    }
-    if (currNode != null) {
-      currNode.accessType = merge(currNode.accessType, accessType);
+    ).get(identifier);
+    for (const entry of path) {
+      let nextHoistableCursor;
+      let nextDepCursor;
+      if (entry.optional) {
+        if (hoistableCursor != null) {
+          nextHoistableCursor =
+            hoistableCursor === null || hoistableCursor === void 0
+              ? void 0
+              : hoistableCursor.properties.get(entry.property);
+        }
+        let accessType;
+        if (
+          hoistableCursor != null &&
+          hoistableCursor.accessType === 'NonNull'
+        ) {
+          accessType = PropertyAccessType.UnconditionalAccess;
+        } else {
+          accessType = PropertyAccessType.OptionalAccess;
+        }
+        nextDepCursor = makeOrMergeProperty(
+          depCursor,
+          entry.property,
+          accessType
+        );
+      } else if (
+        hoistableCursor != null &&
+        hoistableCursor.accessType === 'NonNull'
+      ) {
+        nextHoistableCursor = hoistableCursor.properties.get(entry.property);
+        nextDepCursor = makeOrMergeProperty(
+          depCursor,
+          entry.property,
+          PropertyAccessType.UnconditionalAccess
+        );
+      } else {
+        break;
+      }
+      depCursor = nextDepCursor;
+      hoistableCursor = nextHoistableCursor;
     }
+    depCursor.accessType = merge(
+      depCursor.accessType,
+      PropertyAccessType.OptionalDependency
+    );
   }
   deriveMinimalDependencies() {
     const results = new Set();
     for (const [rootId, rootNode] of __classPrivateFieldGet(
       this,
-      _ReactiveScopeDependencyTreeHIR_roots,
+      _ReactiveScopeDependencyTreeHIR_deps,
       'f'
     ).entries()) {
-      {
-        assertWellFormedTree(rootNode);
-      }
-      const deps = deriveMinimalDependenciesInSubtree(rootNode, []);
-      for (const dep of deps) {
-        results.add({
-          identifier: rootId,
-          path: dep.path.map(s => ({property: s, optional: false})),
-        });
-      }
+      collectMinimalDependenciesInSubtree(rootNode, rootId, [], results);
     }
     return results;
   }
@@ -154541,7 +154898,7 @@ class ReactiveScopeDependencyTreeHIR {
     let res = [];
     for (const [rootId, rootNode] of __classPrivateFieldGet(
       this,
-      _ReactiveScopeDependencyTreeHIR_roots,
+      _ReactiveScopeDependencyTreeHIR_deps,
       'f'
     ).entries()) {
       const rootResults = printSubtree(rootNode, includeAccesses).map(
@@ -154551,95 +154908,106 @@ class ReactiveScopeDependencyTreeHIR {
     }
     return res.flat().join('\n');
   }
+  static debug(roots) {
+    const buf = [`tree() [`];
+    for (const [rootId, rootNode] of roots) {
+      buf.push(`${printIdentifier(rootId)} (${rootNode.accessType}):`);
+      __classPrivateFieldGet(
+        this,
+        _a,
+        'm',
+        _ReactiveScopeDependencyTreeHIR_debugImpl
+      ).call(this, buf, rootNode, 1);
+    }
+    buf.push(']');
+    return buf.length > 2 ? buf.join('\n') : buf.join('');
+  }
 }
-(_ReactiveScopeDependencyTreeHIR_roots = new WeakMap()),
-  (_ReactiveScopeDependencyTreeHIR_instances = new WeakSet()),
+(_a = ReactiveScopeDependencyTreeHIR),
+  (_ReactiveScopeDependencyTreeHIR_hoistableObjects = new WeakMap()),
+  (_ReactiveScopeDependencyTreeHIR_deps = new WeakMap()),
   (_ReactiveScopeDependencyTreeHIR_getOrCreateRoot =
     function _ReactiveScopeDependencyTreeHIR_getOrCreateRoot(
       identifier,
-      accessType
+      roots,
+      defaultAccessType
     ) {
-      let rootNode = __classPrivateFieldGet(
-        this,
-        _ReactiveScopeDependencyTreeHIR_roots,
-        'f'
-      ).get(identifier);
+      let rootNode = roots.get(identifier);
       if (rootNode === undefined) {
-        rootNode = {properties: new Map(), accessType: accessType};
+        rootNode = {properties: new Map(), accessType: defaultAccessType};
+        roots.set(identifier, rootNode);
+      }
+      return rootNode;
+    }),
+  (_ReactiveScopeDependencyTreeHIR_debugImpl =
+    function _ReactiveScopeDependencyTreeHIR_debugImpl(buf, node, depth = 0) {
+      for (const [property, childNode] of node.properties) {
+        buf.push(
+          `${'  '.repeat(depth)}.${property} (${childNode.accessType}):`
+        );
         __classPrivateFieldGet(
           this,
-          _ReactiveScopeDependencyTreeHIR_roots,
-          'f'
-        ).set(identifier, rootNode);
+          _a,
+          'm',
+          _ReactiveScopeDependencyTreeHIR_debugImpl
+        ).call(this, buf, childNode, depth + 1);
       }
-      return rootNode;
     });
 var PropertyAccessType;
 (function (PropertyAccessType) {
-  PropertyAccessType['Access'] = 'Access';
-  PropertyAccessType['NonNullAccess'] = 'NonNullAccess';
-  PropertyAccessType['Dependency'] = 'Dependency';
-  PropertyAccessType['NonNullDependency'] = 'NonNullDependency';
+  PropertyAccessType['OptionalAccess'] = 'OptionalAccess';
+  PropertyAccessType['UnconditionalAccess'] = 'UnconditionalAccess';
+  PropertyAccessType['OptionalDependency'] = 'OptionalDependency';
+  PropertyAccessType['UnconditionalDependency'] = 'UnconditionalDependency';
 })(PropertyAccessType || (PropertyAccessType = {}));
-const MIN_ACCESS_TYPE = PropertyAccessType.Access;
-function isNonNull(access) {
+function isOptional(access) {
   return (
-    access === PropertyAccessType.NonNullAccess ||
-    access === PropertyAccessType.NonNullDependency
+    access === PropertyAccessType.OptionalAccess ||
+    access === PropertyAccessType.OptionalDependency
   );
 }
 function isDependency(access) {
   return (
-    access === PropertyAccessType.Dependency ||
-    access === PropertyAccessType.NonNullDependency
+    access === PropertyAccessType.OptionalDependency ||
+    access === PropertyAccessType.UnconditionalDependency
   );
 }
 function merge(access1, access2) {
-  const resultisNonNull = isNonNull(access1) || isNonNull(access2);
+  const resultIsUnconditional = !(isOptional(access1) && isOptional(access2));
   const resultIsDependency = isDependency(access1) || isDependency(access2);
-  if (resultisNonNull) {
+  if (resultIsUnconditional) {
     if (resultIsDependency) {
-      return PropertyAccessType.NonNullDependency;
+      return PropertyAccessType.UnconditionalDependency;
     } else {
-      return PropertyAccessType.NonNullAccess;
+      return PropertyAccessType.UnconditionalAccess;
     }
   } else {
     if (resultIsDependency) {
-      return PropertyAccessType.Dependency;
+      return PropertyAccessType.OptionalDependency;
     } else {
-      return PropertyAccessType.Access;
+      return PropertyAccessType.OptionalAccess;
     }
   }
 }
-function assertWellFormedTree(node) {
-  let nonNullInChildren = false;
-  for (const childNode of node.properties.values()) {
-    assertWellFormedTree(childNode);
-    nonNullInChildren || (nonNullInChildren = isNonNull(childNode.accessType));
-  }
-  if (nonNullInChildren) {
-    CompilerError.invariant(isNonNull(node.accessType), {
-      reason:
-        '[DeriveMinimialDependencies] Not well formed tree, unexpected non-null node',
-      description: node.accessType,
-      loc: GeneratedSource,
-    });
-  }
-}
-function deriveMinimalDependenciesInSubtree(node, path) {
+function collectMinimalDependenciesInSubtree(
+  node,
+  rootIdentifier,
+  path,
+  results
+) {
   if (isDependency(node.accessType)) {
-    return [{path: path}];
+    results.add({identifier: rootIdentifier, path: path});
   } else {
-    if (isNonNull(node.accessType)) {
-      const result = [];
-      for (const [childName, childNode] of node.properties) {
-        result.push(
-          ...deriveMinimalDependenciesInSubtree(childNode, [...path, childName])
-        );
-      }
-      return result;
-    } else {
-      return [{path: path}];
+    for (const [childName, childNode] of node.properties) {
+      collectMinimalDependenciesInSubtree(
+        childNode,
+        rootIdentifier,
+        [
+          ...path,
+          {property: childName, optional: isOptional(childNode.accessType)},
+        ],
+        results
+      );
     }
   }
 }
@@ -154677,18 +155045,36 @@ function propagateScopeDependenciesHIR(fn) {
   const usedOutsideDeclaringScope =
     findTemporariesUsedOutsideDeclaringScope(fn);
   const temporaries = collectTemporariesSidemap(fn, usedOutsideDeclaringScope);
-  const hoistablePropertyLoads = collectHoistablePropertyLoads(fn, temporaries);
+  const {
+    temporariesReadInOptional: temporariesReadInOptional,
+    processedInstrsInOptional: processedInstrsInOptional,
+    hoistableObjects: hoistableObjects,
+  } = collectOptionalChainSidemap(fn);
+  const hoistablePropertyLoads = keyByScopeId(
+    fn,
+    collectHoistablePropertyLoads(fn, temporaries, hoistableObjects, null)
+  );
   const scopeDeps = collectDependencies(
     fn,
     usedOutsideDeclaringScope,
-    temporaries
+    new Map([...temporaries, ...temporariesReadInOptional]),
+    processedInstrsInOptional
   );
   for (const [scope, deps] of scopeDeps) {
-    const tree = new ReactiveScopeDependencyTreeHIR();
+    if (deps.length === 0) {
+      continue;
+    }
+    const hoistables = hoistablePropertyLoads.get(scope.id);
+    CompilerError.invariant(hoistables != null, {
+      reason: '[PropagateScopeDependencies] Scope not found in tracked blocks',
+      loc: GeneratedSource,
+    });
+    const tree = new ReactiveScopeDependencyTreeHIR(
+      [...hoistables.assumedNonNullObjects].map(o => o.fullPath)
+    );
     for (const dep of deps) {
       tree.addDependency(Object.assign({}, dep));
     }
-    recordHoistablePropertyReads(hoistablePropertyLoads, scope.id, tree);
     const candidates = tree.deriveMinimalDependencies();
     for (const candidateDep of candidates) {
       if (
@@ -154765,7 +155151,12 @@ function collectTemporariesSidemap(fn, usedOutsideDeclaringScope) {
         lvalue.identifier.declarationId
       );
       if (value.kind === 'PropertyLoad' && !usedOutside) {
-        const property = getProperty(value.object, value.property, temporaries);
+        const property = getProperty(
+          value.object,
+          value.property,
+          false,
+          temporaries
+        );
         temporaries.set(lvalue.identifier.id, property);
       } else if (
         value.kind === 'LoadLocal' &&
@@ -154782,20 +155173,20 @@ function collectTemporariesSidemap(fn, usedOutsideDeclaringScope) {
   }
   return temporaries;
 }
-function getProperty(object, propertyName, temporaries) {
+function getProperty(object, propertyName, optional, temporaries) {
   const resolvedDependency = temporaries.get(object.identifier.id);
   let property;
   if (resolvedDependency == null) {
     property = {
       identifier: object.identifier,
-      path: [{property: propertyName, optional: false}],
+      path: [{property: propertyName, optional: optional}],
     };
   } else {
     property = {
       identifier: resolvedDependency.identifier,
       path: [
         ...resolvedDependency.path,
-        {property: propertyName, optional: false},
+        {property: propertyName, optional: optional},
       ],
     };
   }
@@ -154914,10 +155305,11 @@ class Context {
         : {identifier: place.identifier, path: []}
     );
   }
-  visitProperty(object, property) {
+  visitProperty(object, property, optional) {
     const nextDependency = getProperty(
       object,
       property,
+      optional,
       __classPrivateFieldGet(this, _Context_temporaries, 'f')
     );
     this.visitDependency(nextDependency);
@@ -155048,7 +155440,7 @@ function handleInstruction(instr, context) {
     }
   } else if (value.kind === 'PropertyLoad') {
     if (context.isUsedOutsideDeclaringScope(lvalue)) {
-      context.visitProperty(value.object, value.property);
+      context.visitProperty(value.object, value.property, false);
     }
   } else if (value.kind === 'StoreLocal') {
     context.visitOperand(value.value);
@@ -155079,7 +155471,12 @@ function handleInstruction(instr, context) {
   }
   context.declare(lvalue.identifier, {id: id, scope: context.currentScope});
 }
-function collectDependencies(fn, usedOutsideDeclaringScope, temporaries) {
+function collectDependencies(
+  fn,
+  usedOutsideDeclaringScope,
+  temporaries,
+  processedInstrsInOptional
+) {
   const context = new Context(usedOutsideDeclaringScope, temporaries);
   for (const param of fn.params) {
     if (param.kind === 'Identifier') {
@@ -155116,25 +155513,27 @@ function collectDependencies(fn, usedOutsideDeclaringScope, temporaries) {
           : scopeBlockInfo.pruned
       );
     }
+    for (const phi of block.phis) {
+      for (const operand of phi.operands) {
+        const maybeOptionalChain = temporaries.get(operand[1].id);
+        if (maybeOptionalChain) {
+          context.visitDependency(maybeOptionalChain);
+        }
+      }
+    }
     for (const instr of block.instructions) {
-      handleInstruction(instr, context);
+      if (!processedInstrsInOptional.has(instr.id)) {
+        handleInstruction(instr, context);
+      }
     }
-    for (const place of eachTerminalOperand(block.terminal)) {
-      context.visitOperand(place);
+    if (!processedInstrsInOptional.has(block.terminal.id)) {
+      for (const place of eachTerminalOperand(block.terminal)) {
+        context.visitOperand(place);
+      }
     }
   }
   return context.deps;
 }
-function recordHoistablePropertyReads(nodes, scopeId, tree) {
-  const node = nodes.get(scopeId);
-  CompilerError.invariant(node != null, {
-    reason: '[PropagateScopeDependencies] Scope not found in tracked blocks',
-    loc: GeneratedSource,
-  });
-  for (const item of node.assumedNonNullObjects) {
-    tree.markNodesNonNull(Object.assign({}, item.fullPath));
-  }
-}
 function* run(
   func,
   config,