babel-plugin-react-compiler 0.0.0-experimental-3feb7e4-20240930 → 0.0.0-experimental-27e0f40-20241002

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;
 }
@@ -144911,7 +144931,7 @@ class ReactiveScopeDependencyTree {
       _ReactiveScopeDependencyTree_getOrCreateRoot
     ).call(this, dep.identifier);
     for (const item of path) {
-      let currChild = getOrMakeProperty$1(currNode, item.property);
+      let currChild = getOrMakeProperty(currNode, item.property);
       const accessType = inConditional
         ? PropertyAccessType$1.ConditionalAccess
         : item.optional
@@ -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
     );
@@ -145319,10 +145339,10 @@ function printSubtree$1(node, includeAccesses) {
   }
   return results;
 }
-function getOrMakeProperty$1(node, property) {
+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,10 +154239,19 @@ function validateNoJSXInTryStatement(fn) {
     throw errors;
   }
 }
-var _Tree_instances, _a, _Tree_getOrCreateRoot, _Tree_getOrCreateProperty;
-function collectHoistablePropertyLoads(fn, temporaries) {
-  const nodes = collectPropertyLoadsInBlocks(fn, temporaries);
-  propagateNonNull(fn, nodes);
+function collectHoistablePropertyLoads(
+  fn,
+  temporaries,
+  hoistableFromOptionals
+) {
+  const registry = new PropertyPathRegistry();
+  const nodes = collectNonNullsInBlocks(
+    fn,
+    temporaries,
+    hoistableFromOptionals,
+    registry
+  );
+  propagateNonNull(fn, nodes, registry);
   const nodesKeyedByScopeId = new Map();
   for (const [_, block] of fn.body.blocks) {
     if (block.terminal.kind === 'scope') {
@@ -154234,122 +154263,148 @@ function collectHoistablePropertyLoads(fn, temporaries) {
   }
   return nodesKeyedByScopeId;
 }
-function getProperty(object, propertyName, temporaries) {
-  const resolvedDependency = temporaries.get(object.identifier.id);
-  let property;
-  if (resolvedDependency == null) {
-    property = {
-      identifier: object.identifier,
-      path: [{property: propertyName, optional: false}],
-    };
-  } else {
-    property = {
-      identifier: resolvedDependency.identifier,
-      path: [
-        ...resolvedDependency.path,
-        {property: propertyName, optional: false},
-      ],
-    };
-  }
-  return property;
-}
-class Tree {
+class PropertyPathRegistry {
   constructor() {
-    _Tree_instances.add(this);
     this.roots = new Map();
   }
-  getPropertyLoadNode(n) {
-    CompilerError.invariant(n.path.length > 0, {
-      reason:
-        '[CollectHoistablePropertyLoads] Expected property node, found root node',
-      loc: GeneratedSource,
-    });
-    let currNode = __classPrivateFieldGet(
-      this,
-      _Tree_instances,
-      'm',
-      _Tree_getOrCreateRoot
-    ).call(this, n.identifier);
-    for (let i = 0; i < n.path.length - 1; i++) {
-      currNode = assertNonNull(currNode.properties.get(n.path[i].property));
-    }
-    return __classPrivateFieldGet(_a, _a, 'm', _Tree_getOrCreateProperty).call(
-      _a,
-      currNode,
-      n.path.at(-1).property
-    );
-  }
-}
-(_a = Tree),
-  (_Tree_instances = new WeakSet()),
-  (_Tree_getOrCreateRoot = function _Tree_getOrCreateRoot(identifier) {
-    let rootNode = this.roots.get(identifier);
+  getOrCreateIdentifier(identifier) {
+    let rootNode = this.roots.get(identifier.id);
     if (rootNode === undefined) {
       rootNode = {
-        root: identifier,
+        root: identifier.id,
         properties: new Map(),
+        optionalProperties: new Map(),
         fullPath: {identifier: identifier, path: []},
+        hasOptional: false,
         parent: null,
       };
-      this.roots.set(identifier, rootNode);
+      this.roots.set(identifier.id, rootNode);
     }
     return rootNode;
-  }),
-  (_Tree_getOrCreateProperty = function _Tree_getOrCreateProperty(
-    node,
-    property
-  ) {
-    let child = node.properties.get(property);
+  }
+  static getOrCreatePropertyEntry(parent, entry) {
+    const map = entry.optional ? parent.optionalProperties : parent.properties;
+    let child = map.get(entry.property);
     if (child == null) {
       child = {
         properties: new Map(),
-        parent: node,
+        optionalProperties: new Map(),
+        parent: parent,
         fullPath: {
-          identifier: node.fullPath.identifier,
-          path: node.fullPath.path.concat([
-            {property: property, optional: false},
-          ]),
+          identifier: parent.fullPath.identifier,
+          path: parent.fullPath.path.concat(entry),
         },
+        hasOptional: parent.hasOptional || entry.optional,
       };
-      node.properties.set(property, child);
+      map.set(entry.property, child);
     }
     return child;
-  });
-function collectPropertyLoadsInBlocks(fn, temporaries) {
+  }
+  getOrCreateProperty(n) {
+    let currNode = this.getOrCreateIdentifier(n.identifier);
+    if (n.path.length === 0) {
+      return currNode;
+    }
+    for (let i = 0; i < n.path.length - 1; i++) {
+      currNode = PropertyPathRegistry.getOrCreatePropertyEntry(
+        currNode,
+        n.path[i]
+      );
+    }
+    return PropertyPathRegistry.getOrCreatePropertyEntry(
+      currNode,
+      n.path.at(-1)
+    );
+  }
+}
+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 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);
+        knownImmutableIdentifiers.add(p.identifier.id);
       }
     }
   }
-  const tree = new Tree();
+  const knownNonNullIdentifiers = new Set();
+  if (
+    fn.fnType === 'Component' &&
+    fn.params.length > 0 &&
+    fn.params[0].kind === 'Identifier'
+  ) {
+    const identifier = fn.params[0].identifier;
+    knownNonNullIdentifiers.add(registry.getOrCreateIdentifier(identifier));
+  }
   const nodes = new Map();
   for (const [_, block] of fn.body.blocks) {
-    const assumedNonNullObjects = new Set();
+    const assumedNonNullObjects = new Set(knownNonNullIdentifiers);
+    const maybeOptionalChain = hoistableFromOptionals.get(block.id);
+    if (maybeOptionalChain != null) {
+      assumedNonNullObjects.add(
+        registry.getOrCreateProperty(maybeOptionalChain)
+      );
+    }
     for (const instr of block.instructions) {
       if (instr.value.kind === 'PropertyLoad') {
-        const property = getProperty(
-          instr.value.object,
-          instr.value.property,
-          temporaries
+        const source =
+          (_a = temporaries.get(instr.value.object.identifier.id)) !== null &&
+          _a !== void 0
+            ? _a
+            : {identifier: instr.value.object.identifier, path: []};
+        addNonNullPropertyPath(
+          instr.value.object.identifier,
+          registry.getOrCreateProperty(source),
+          instr.id,
+          knownImmutableIdentifiers,
+          assumedNonNullObjects
         );
-        const propertyNode = tree.getPropertyLoadNode(property);
-        const object = instr.value.object.identifier;
-        const isMutableAtInstr =
-          object.mutableRange.end > object.mutableRange.start + 1 &&
-          object.scope != null &&
-          inRange(instr, object.scope.range);
-        if (
-          !isMutableAtInstr ||
-          knownImmutableIdentifiers.has(propertyNode.fullPath.identifier)
-        ) {
-          let curr = propertyNode.parent;
-          while (curr != null) {
-            assumedNonNullObjects.add(curr);
-            curr = curr.parent;
-          }
+      } 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
+          );
         }
       }
     }
@@ -154360,7 +154415,7 @@ function collectPropertyLoadsInBlocks(fn, temporaries) {
   }
   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) {
@@ -154371,13 +154426,8 @@ function propagateNonNull(fn, nodes) {
       terminalPreds.add(blockId);
     }
   }
-  function recursivelyPropagateNonNull(
-    nodeId,
-    direction,
-    traversalState,
-    nonNullObjectsByBlock
-  ) {
-    var _b;
+  function recursivelyPropagateNonNull(nodeId, direction, traversalState) {
+    var _a;
     if (traversalState.has(nodeId)) {
       return false;
     }
@@ -154391,8 +154441,8 @@ function propagateNonNull(fn, nodes) {
     }
     const neighbors = Array.from(
       direction === 'backward'
-        ? (_b = blockSuccessors.get(nodeId)) !== null && _b !== void 0
-          ? _b
+        ? (_a = blockSuccessors.get(nodeId)) !== null && _a !== void 0
+          ? _a
           : []
         : node.block.preds
     );
@@ -154402,8 +154452,7 @@ function propagateNonNull(fn, nodes) {
         const neighborChanged = recursivelyPropagateNonNull(
           pred,
           direction,
-          traversalState,
-          nonNullObjectsByBlock
+          traversalState
         );
         changed || (changed = neighborChanged);
       }
@@ -154411,35 +154460,33 @@ function propagateNonNull(fn, nodes) {
     const neighborAccesses = Set_intersect(
       Array.from(neighbors)
         .filter(n => traversalState.get(n) === 'done')
-        .map(n => assertNonNull(nonNullObjectsByBlock.get(n)))
+        .map(n => assertNonNull(nodes.get(n)).assumedNonNullObjects)
     );
-    const prevObjects = assertNonNull(nonNullObjectsByBlock.get(nodeId));
-    const newObjects = Set_union(prevObjects, neighborAccesses);
-    nonNullObjectsByBlock.set(nodeId, newObjects);
+    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 !== newObjects.size);
+    changed || (changed = !Set_equal(prevObjects, mergedObjects));
     return changed;
   }
-  const fromEntry = new Map();
-  const fromExit = new Map();
-  for (const [blockId, blockInfo] of nodes) {
-    fromEntry.set(blockId, blockInfo.assumedNonNullObjects);
-    fromExit.set(blockId, blockInfo.assumedNonNullObjects);
-  }
   const traversalState = new Map();
   const reversedBlocks = [...fn.body.blocks];
   reversedBlocks.reverse();
-  let i = 0;
   let changed;
+  let i = 0;
   do {
-    i++;
+    CompilerError.invariant(i++ < 100, {
+      reason:
+        '[CollectHoistablePropertyLoads] fixed point iteration did not terminate after 100 loops',
+      loc: GeneratedSource,
+    });
     changed = false;
     for (const [blockId] of fn.body.blocks) {
       const forwardChanged = recursivelyPropagateNonNull(
         blockId,
         'forward',
-        traversalState,
-        fromEntry
+        traversalState
       );
       changed || (changed = forwardChanged);
     }
@@ -154448,33 +154495,12 @@ function propagateNonNull(fn, nodes) {
       const backwardChanged = recursivelyPropagateNonNull(
         blockId,
         'backward',
-        traversalState,
-        fromExit
+        traversalState
       );
       changed || (changed = backwardChanged);
     }
     traversalState.clear();
   } while (changed);
-  CompilerError.invariant(i <= 2, {
-    reason: 'require fixed-point iteration',
-    description: `#iterations = ${i}`,
-    loc: GeneratedSource,
-  });
-  CompilerError.invariant(
-    fromEntry.size === fromExit.size && fromEntry.size === nodes.size,
-    {
-      reason:
-        'bad sizes after calculating fromEntry + fromExit ' +
-        `${fromEntry.size} ${fromExit.size} ${nodes.size}`,
-      loc: GeneratedSource,
-    }
-  );
-  for (const [id, node] of nodes) {
-    node.assumedNonNullObjects = Set_union(
-      assertNonNull(fromEntry.get(id)),
-      assertNonNull(fromExit.get(id))
-    );
-  }
 }
 function assertNonNull(value, source) {
   CompilerError.invariant(value != null, {
@@ -154484,67 +154510,156 @@ 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);
+}
+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, false);
-    const accessType = PropertyAccessType.Access;
-    currNode.accessType = merge(currNode.accessType, accessType);
-    for (const property of path) {
-      let currChild = getOrMakeProperty(currNode, property.property);
-      currChild.accessType = merge(currChild.accessType, 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;
   }
@@ -154552,7 +154667,7 @@ class ReactiveScopeDependencyTreeHIR {
     let res = [];
     for (const [rootId, rootNode] of __classPrivateFieldGet(
       this,
-      _ReactiveScopeDependencyTreeHIR_roots,
+      _ReactiveScopeDependencyTreeHIR_deps,
       'f'
     ).entries()) {
       const rootResults = printSubtree(rootNode, includeAccesses).map(
@@ -154562,100 +154677,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,
-      isNonNull
+      roots,
+      defaultAccessType
     ) {
-      let rootNode = __classPrivateFieldGet(
-        this,
-        _ReactiveScopeDependencyTreeHIR_roots,
-        'f'
-      ).get(identifier);
+      let rootNode = roots.get(identifier);
       if (rootNode === undefined) {
-        rootNode = {
-          properties: new Map(),
-          accessType: isNonNull
-            ? PropertyAccessType.NonNullAccess
-            : PropertyAccessType.Access,
-        };
+        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
+      );
     }
   }
 }
@@ -154670,14 +154791,202 @@ function printSubtree(node, includeAccesses) {
   }
   return results;
 }
-function getOrMakeProperty(node, property) {
+function makeOrMergeProperty(node, property, accessType) {
   let child = node.properties.get(property);
   if (child == null) {
-    child = {properties: new Map(), accessType: MIN_ACCESS_TYPE};
+    child = {properties: new Map(), accessType: accessType};
     node.properties.set(property, child);
+  } else {
+    child.accessType = merge(child.accessType, 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,
@@ -154691,18 +155000,37 @@ 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 = collectHoistablePropertyLoads(
+    fn,
+    temporaries,
+    hoistableObjects
+  );
   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 (
@@ -154779,7 +155107,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' &&
@@ -154796,6 +155129,25 @@ function collectTemporariesSidemap(fn, usedOutsideDeclaringScope) {
   }
   return 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: optional}],
+    };
+  } else {
+    property = {
+      identifier: resolvedDependency.identifier,
+      path: [
+        ...resolvedDependency.path,
+        {property: propertyName, optional: optional},
+      ],
+    };
+  }
+  return property;
+}
 class Context {
   constructor(temporariesUsedOutsideScope, temporaries) {
     _Context_instances.add(this);
@@ -154909,10 +155261,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);
@@ -155043,7 +155396,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);
@@ -155074,7 +155427,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') {
@@ -155111,25 +155469,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,