babel-plugin-react-compiler 0.0.0-experimental-e504e66-20241010 → 0.0.0-experimental-fa06e2c-20241014

package/dist/index.js

@@ -111685,12 +111685,34 @@ var parse$1 = function parse(text, reviver) {
 function internalize(holder, name, reviver) {
   const value = holder[name];
   if (value != null && typeof value === 'object') {
-    for (const key in value) {
-      const replacement = internalize(value, key, reviver);
-      if (replacement === undefined) {
-        delete value[key];
-      } else {
-        value[key] = replacement;
+    if (Array.isArray(value)) {
+      for (let i = 0; i < value.length; i++) {
+        const key = String(i);
+        const replacement = internalize(value, key, reviver);
+        if (replacement === undefined) {
+          delete value[key];
+        } else {
+          Object.defineProperty(value, key, {
+            value: replacement,
+            writable: true,
+            enumerable: true,
+            configurable: true,
+          });
+        }
+      }
+    } else {
+      for (const key in value) {
+        const replacement = internalize(value, key, reviver);
+        if (replacement === undefined) {
+          delete value[key];
+        } else {
+          Object.defineProperty(value, key, {
+            value: replacement,
+            writable: true,
+            enumerable: true,
+            configurable: true,
+          });
+        }
       }
     }
   }
@@ -112383,7 +112405,12 @@ function push() {
     if (Array.isArray(parent)) {
       parent.push(value);
     } else {
-      parent[key] = value;
+      Object.defineProperty(parent, key, {
+        value: value,
+        writable: true,
+        enumerable: true,
+        configurable: true,
+      });
     }
   }
   if (value !== null && typeof value === 'object') {
@@ -124423,13 +124450,13 @@ function printInstruction(instr) {
 }
 function printPhi(phi) {
   const items = [];
-  items.push(printIdentifier(phi.id));
-  items.push(printMutableRange(phi.id));
-  items.push(printType(phi.id.type));
+  items.push(printPlace(phi.place));
+  items.push(printMutableRange(phi.place.identifier));
+  items.push(printType(phi.place.identifier.type));
   items.push(': phi(');
   const phis = [];
-  for (const [blockId, id] of phi.operands) {
-    phis.push(`bb${blockId}: ${printIdentifier(id)}`);
+  for (const [blockId, place] of phi.operands) {
+    phis.push(`bb${blockId}: ${printPlace(place)}`);
   }
   items.push(phis.join(', '));
   items.push(')');
@@ -126167,9 +126194,9 @@ function assertConsistentIdentifiers(fn) {
   const assignments = new Set();
   for (const [, block] of fn.body.blocks) {
     for (const phi of block.phis) {
-      validate(identifiers, phi.id);
+      validate(identifiers, phi.place.identifier);
       for (const [, operand] of phi.operands) {
-        validate(identifiers, operand);
+        validate(identifiers, operand.identifier);
       }
     }
     for (const instr of block.instructions) {
@@ -126342,9 +126369,9 @@ function assertValidBlockNesting(fn) {
 function assertValidMutableRanges(fn) {
   for (const [, block] of fn.body.blocks) {
     for (const phi of block.phis) {
-      visitIdentifier(phi.id);
+      visitIdentifier(phi.place.identifier);
       for (const [, operand] of phi.operands) {
-        visitIdentifier(operand);
+        visitIdentifier(operand.identifier);
       }
     }
     for (const instr of block.instructions) {
@@ -135287,20 +135314,14 @@ function mergeConsecutiveBlocks(fn) {
         id: predecessor.terminal.id,
         lvalue: {
           kind: 'Identifier',
-          identifier: phi.id,
+          identifier: phi.place.identifier,
           effect: exports.Effect.ConditionallyMutate,
           reactive: false,
           loc: GeneratedSource,
         },
         value: {
           kind: 'LoadLocal',
-          place: {
-            kind: 'Identifier',
-            identifier: operand,
-            effect: exports.Effect.Read,
-            reactive: false,
-            loc: GeneratedSource,
-          },
+          place: Object.assign({}, operand),
           loc: GeneratedSource,
         },
         loc: GeneratedSource,
@@ -137226,8 +137247,9 @@ function findDisjointMutableValues(fn) {
   for (const [_, block] of fn.body.blocks) {
     for (const phi of block.phis) {
       if (
-        phi.id.mutableRange.start + 1 !== phi.id.mutableRange.end &&
-        phi.id.mutableRange.end >
+        phi.place.identifier.mutableRange.start + 1 !==
+          phi.place.identifier.mutableRange.end &&
+        phi.place.identifier.mutableRange.end >
           ((_b =
             (_a = block.instructions.at(0)) === null || _a === void 0
               ? void 0
@@ -137235,18 +137257,20 @@ function findDisjointMutableValues(fn) {
             ? _b
             : block.terminal.id)
       ) {
-        const operands = [phi.id];
-        const declaration = declarations.get(phi.id.declarationId);
+        const operands = [phi.place.identifier];
+        const declaration = declarations.get(
+          phi.place.identifier.declarationId
+        );
         if (declaration !== undefined) {
           operands.push(declaration);
         }
         for (const [_, phiId] of phi.operands) {
-          operands.push(phiId);
+          operands.push(phiId.identifier);
         }
         scopeIdentifiers.union(operands);
       } else if (fn.env.config.enableForest) {
         for (const [, phiId] of phi.operands) {
-          scopeIdentifiers.union([phi.id, phiId]);
+          scopeIdentifiers.union([phi.place.identifier, phiId.identifier]);
         }
       }
     }
@@ -137938,26 +137962,18 @@ function eliminateRedundantPhi(fn, sharedRewrites) {
       }
       visited.add(blockId);
       phis: for (const phi of block.phis) {
-        phi.operands = new Map(
-          Array.from(phi.operands).map(([block, id]) => {
-            var _a;
-            return [
-              block,
-              (_a = rewrites.get(id)) !== null && _a !== void 0 ? _a : id,
-            ];
-          })
-        );
+        phi.operands.forEach((place, _) => rewritePlace(place, rewrites));
         let same = null;
         for (const [_, operand] of phi.operands) {
           if (
-            (same !== null && operand.id === same.id) ||
-            operand.id === phi.id.id
+            (same !== null && operand.identifier.id === same.id) ||
+            operand.identifier.id === phi.place.identifier.id
           ) {
             continue;
           } else if (same !== null) {
             continue phis;
           } else {
-            same = operand;
+            same = operand.identifier;
           }
         }
         CompilerError.invariant(same !== null, {
@@ -137966,7 +137982,7 @@ function eliminateRedundantPhi(fn, sharedRewrites) {
           loc: null,
           suggestions: null,
         });
-        rewrites.set(phi.id, same);
+        rewrites.set(phi.place.identifier, same);
         block.phis.delete(phi);
       }
       for (const instr of block.instructions) {
@@ -138082,57 +138098,71 @@ class SSABuilder {
   }
   getPlace(oldPlace) {
     const newId = this.getIdAt(
-      oldPlace.identifier,
+      oldPlace,
       __classPrivateFieldGet(this, _SSABuilder_current, 'f').id
     );
     return Object.assign(Object.assign({}, oldPlace), {identifier: newId});
   }
-  getIdAt(oldId, blockId) {
+  getIdAt(oldPlace, blockId) {
     const block = __classPrivateFieldGet(this, _SSABuilder_blocks, 'f').get(
       blockId
     );
     const state = __classPrivateFieldGet(this, _SSABuilder_states, 'f').get(
       block
     );
-    if (state.defs.has(oldId)) {
-      return state.defs.get(oldId);
+    if (state.defs.has(oldPlace.identifier)) {
+      return state.defs.get(oldPlace.identifier);
     }
     if (block.preds.size == 0) {
-      __classPrivateFieldGet(this, _SSABuilder_unknown, 'f').add(oldId);
-      return oldId;
+      __classPrivateFieldGet(this, _SSABuilder_unknown, 'f').add(
+        oldPlace.identifier
+      );
+      return oldPlace.identifier;
     }
     if (this.unsealedPreds.get(block) > 0) {
-      const newId = this.makeId(oldId);
-      state.incompletePhis.push({oldId: oldId, newId: newId});
-      state.defs.set(oldId, newId);
+      const newId = this.makeId(oldPlace.identifier);
+      state.incompletePhis.push({
+        oldPlace: oldPlace,
+        newPlace: Object.assign(Object.assign({}, oldPlace), {
+          identifier: newId,
+        }),
+      });
+      state.defs.set(oldPlace.identifier, newId);
       return newId;
     }
     if (block.preds.size == 1) {
       const [pred] = block.preds;
-      const newId = this.getIdAt(oldId, pred);
-      state.defs.set(oldId, newId);
+      const newId = this.getIdAt(oldPlace, pred);
+      state.defs.set(oldPlace.identifier, newId);
       return newId;
     }
-    const newId = this.makeId(oldId);
-    state.defs.set(oldId, newId);
-    return this.addPhi(block, oldId, newId);
+    const newId = this.makeId(oldPlace.identifier);
+    state.defs.set(oldPlace.identifier, newId);
+    return this.addPhi(
+      block,
+      oldPlace,
+      Object.assign(Object.assign({}, oldPlace), {identifier: newId})
+    );
   }
-  addPhi(block, oldId, newId) {
+  addPhi(block, oldPlace, newPlace) {
     const predDefs = new Map();
     for (const predBlockId of block.preds) {
-      const predId = this.getIdAt(oldId, predBlockId);
-      predDefs.set(predBlockId, predId);
+      const predId = this.getIdAt(oldPlace, predBlockId);
+      predDefs.set(
+        predBlockId,
+        Object.assign(Object.assign({}, oldPlace), {identifier: predId})
+      );
     }
-    const phi = {kind: 'Phi', id: newId, operands: predDefs};
+    const phi = {kind: 'Phi', place: newPlace, operands: predDefs};
     block.phis.add(phi);
-    return newId;
+    return newPlace.identifier;
   }
   fixIncompletePhis(block) {
     const state = __classPrivateFieldGet(this, _SSABuilder_states, 'f').get(
       block
     );
     for (const phi of state.incompletePhis) {
-      this.addPhi(block, phi.oldId, phi.newId);
+      this.addPhi(block, phi.oldPlace, phi.newPlace);
     }
   }
   startBlock(block) {
@@ -138156,7 +138186,7 @@ class SSABuilder {
       }
       for (const incompletePhi of state.incompletePhis) {
         text.push(
-          `  iphi $${printIdentifier(incompletePhi.newId)} = $${printIdentifier(incompletePhi.oldId)}`
+          `  iphi $${printPlace(incompletePhi.newPlace)} = $${printPlace(incompletePhi.oldPlace)}`
         );
       }
     }
@@ -138426,7 +138456,7 @@ function applyConstantPropagation(fn, constants) {
     for (const phi of block.phis) {
       let value = evaluatePhi(phi, constants);
       if (value !== null) {
-        constants.set(phi.id.id, value);
+        constants.set(phi.place.identifier.id, value);
       }
     }
     for (let i = 0; i < block.instructions.length; i++) {
@@ -138467,7 +138497,9 @@ function evaluatePhi(phi, constants) {
   let value = null;
   for (const [, operand] of phi.operands) {
     const operandValue =
-      (_a = constants.get(operand.id)) !== null && _a !== void 0 ? _a : null;
+      (_a = constants.get(operand.identifier.id)) !== null && _a !== void 0
+        ? _a
+        : null;
     if (operandValue === null) {
       return null;
     }
@@ -138800,7 +138832,7 @@ function deadCodeElimination(fn) {
   const state = findReferencedIdentifiers(fn);
   for (const [, block] of fn.body.blocks) {
     for (const phi of block.phis) {
-      if (!state.isIdOrNameUsed(phi.id)) {
+      if (!state.isIdOrNameUsed(phi.place.identifier)) {
         block.phis.delete(phi);
       }
     }
@@ -138880,9 +138912,9 @@ function findReferencedIdentifiers(fn) {
         }
       }
       for (const phi of block.phis) {
-        if (state.isIdOrNameUsed(phi.id)) {
+        if (state.isIdOrNameUsed(phi.place.identifier)) {
           for (const [_pred, operand] of phi.operands) {
-            state.reference(operand);
+            state.reference(operand.identifier);
           }
         }
       }
@@ -139080,7 +139112,7 @@ function pruneMaybeThrows(fn) {
             CompilerError.invariant(mappedTerminal != null, {
               reason: `Expected non-existing phi operand's predecessor to have been mapped to a new terminal`,
               loc: GeneratedSource,
-              description: `Could not find mapping for predecessor bb${predecessor} in block bb${block.id} for phi ${printIdentifier(phi.id)}`,
+              description: `Could not find mapping for predecessor bb${predecessor} in block bb${block.id} for phi ${printPlace(phi.place)}`,
               suggestions: null,
             });
             phi.operands.delete(predecessor);
@@ -147303,7 +147335,7 @@ class InferenceState {
         this,
         _InferenceState_variables,
         'f'
-      ).get(operand.id);
+      ).get(operand.identifier.id);
       if (operandValues === undefined) continue;
       for (const v of operandValues) {
         values.add(v);
@@ -147311,7 +147343,7 @@ class InferenceState {
     }
     if (values.size > 0) {
       __classPrivateFieldGet(this, _InferenceState_variables, 'f').set(
-        phi.id.id,
+        phi.place.identifier.id,
         values
       );
     }
@@ -149638,7 +149670,7 @@ function inferAliasForPhis(func, aliases) {
   for (const [_, block] of func.body.blocks) {
     for (const phi of block.phis) {
       const isPhiMutatedAfterCreation =
-        phi.id.mutableRange.end >
+        phi.place.identifier.mutableRange.end >
         ((_b =
           (_a = block.instructions.at(0)) === null || _a === void 0
             ? void 0
@@ -149647,7 +149679,7 @@ function inferAliasForPhis(func, aliases) {
           : block.terminal.id);
       if (isPhiMutatedAfterCreation) {
         for (const [, operand] of phi.operands) {
-          aliases.union([phi.id, operand]);
+          aliases.union([phi.place.identifier, operand.identifier]);
         }
       }
     }
@@ -149721,7 +149753,7 @@ function inferMutableLifetimes(func, inferMutableRangeForStores) {
   for (const [_, block] of func.body.blocks) {
     for (const phi of block.phis) {
       const isPhiMutatedAfterCreation =
-        phi.id.mutableRange.end >
+        phi.place.identifier.mutableRange.end >
         ((_b =
           (_a = block.instructions.at(0)) === null || _a === void 0
             ? void 0
@@ -149731,14 +149763,18 @@ function inferMutableLifetimes(func, inferMutableRangeForStores) {
       if (
         inferMutableRangeForStores &&
         isPhiMutatedAfterCreation &&
-        phi.id.mutableRange.start === 0
+        phi.place.identifier.mutableRange.start === 0
       ) {
         for (const [, operand] of phi.operands) {
-          if (phi.id.mutableRange.start === 0) {
-            phi.id.mutableRange.start = operand.mutableRange.start;
+          if (phi.place.identifier.mutableRange.start === 0) {
+            phi.place.identifier.mutableRange.start =
+              operand.identifier.mutableRange.start;
           } else {
-            phi.id.mutableRange.start = makeInstructionId(
-              Math.min(phi.id.mutableRange.start, operand.mutableRange.start)
+            phi.place.identifier.mutableRange.start = makeInstructionId(
+              Math.min(
+                phi.place.identifier.mutableRange.start,
+                operand.identifier.mutableRange.start
+              )
             );
           }
         }
@@ -150335,7 +150371,6 @@ function findOptionalPlaces(fn) {
   return optionals;
 }
 function inferReactivePlaces(fn) {
-  var _a;
   const reactiveIdentifiers = new ReactivityMap(findDisjointMutableValues(fn));
   for (const param of fn.params) {
     const place = param.kind === 'Identifier' ? param : param.place;
@@ -150380,26 +150415,25 @@ function inferReactivePlaces(fn) {
     return false;
   }
   do {
-    const identifierMapping = new Map();
     for (const [, block] of fn.body.blocks) {
       let hasReactiveControl = isReactiveControlledBlock(block.id);
       for (const phi of block.phis) {
-        if (reactiveIdentifiers.isReactiveIdentifier(phi.id)) {
+        if (reactiveIdentifiers.isReactive(phi.place)) {
           continue;
         }
         let isPhiReactive = false;
         for (const [, operand] of phi.operands) {
-          if (reactiveIdentifiers.isReactiveIdentifier(operand)) {
+          if (reactiveIdentifiers.isReactive(operand)) {
             isPhiReactive = true;
             break;
           }
         }
         if (isPhiReactive) {
-          reactiveIdentifiers.markReactiveIdentifier(phi.id);
+          reactiveIdentifiers.markReactive(phi.place);
         } else {
           for (const [pred] of phi.operands) {
             if (isReactiveControlledBlock(pred)) {
-              reactiveIdentifiers.markReactiveIdentifier(phi.id);
+              reactiveIdentifiers.markReactive(phi.place);
               break;
             }
           }
@@ -150441,10 +150475,6 @@ function inferReactivePlaces(fn) {
               case exports.Effect.ConditionallyMutate:
               case exports.Effect.Mutate: {
                 if (isMutable(instruction, operand)) {
-                  const resolvedId = identifierMapping.get(operand.identifier);
-                  if (resolvedId !== undefined) {
-                    reactiveIdentifiers.markReactiveIdentifier(resolvedId);
-                  }
                   reactiveIdentifiers.markReactive(operand);
                 }
                 break;
@@ -150470,32 +150500,6 @@ function inferReactivePlaces(fn) {
             }
           }
         }
-        switch (value.kind) {
-          case 'LoadLocal': {
-            identifierMapping.set(
-              instruction.lvalue.identifier,
-              value.place.identifier
-            );
-            break;
-          }
-          case 'PropertyLoad':
-          case 'ComputedLoad': {
-            const resolvedId =
-              (_a = identifierMapping.get(value.object.identifier)) !== null &&
-              _a !== void 0
-                ? _a
-                : value.object.identifier;
-            identifierMapping.set(instruction.lvalue.identifier, resolvedId);
-            break;
-          }
-          case 'LoadContext': {
-            identifierMapping.set(
-              instruction.lvalue.identifier,
-              value.place.identifier
-            );
-            break;
-          }
-        }
       }
       for (const operand of eachTerminalOperand(block.terminal)) {
         reactiveIdentifiers.isReactive(operand);
@@ -150551,32 +150555,26 @@ class ReactivityMap {
     this.aliasedIdentifiers = aliasedIdentifiers;
   }
   isReactive(place) {
-    const reactive = this.isReactiveIdentifier(place.identifier);
-    if (reactive) {
-      place.reactive = true;
-    }
-    return reactive;
-  }
-  isReactiveIdentifier(inputIdentifier) {
     var _a;
     const identifier =
-      (_a = this.aliasedIdentifiers.find(inputIdentifier)) !== null &&
+      (_a = this.aliasedIdentifiers.find(place.identifier)) !== null &&
       _a !== void 0
         ? _a
-        : inputIdentifier;
-    return this.reactive.has(identifier.id);
+        : place.identifier;
+    const reactive = this.reactive.has(identifier.id);
+    if (reactive) {
+      place.reactive = true;
+    }
+    return reactive;
   }
   markReactive(place) {
-    place.reactive = true;
-    this.markReactiveIdentifier(place.identifier);
-  }
-  markReactiveIdentifier(inputIdentifier) {
     var _a;
+    place.reactive = true;
     const identifier =
-      (_a = this.aliasedIdentifiers.find(inputIdentifier)) !== null &&
+      (_a = this.aliasedIdentifiers.find(place.identifier)) !== null &&
       _a !== void 0
         ? _a
-        : inputIdentifier;
+        : place.identifier;
     if (!this.reactive.has(identifier.id)) {
       this.hasChanges = true;
       this.reactive.add(identifier.id);
@@ -151606,7 +151604,7 @@ function inferTypes(func) {
 function apply(func, unifier) {
   for (const [_, block] of func.body.blocks) {
     for (const phi of block.phis) {
-      phi.id.type = unifier.get(phi.id.type);
+      phi.place.identifier.type = unifier.get(phi.place.identifier.type);
     }
     for (const instr of block.instructions) {
       for (const operand of eachInstructionLValue(instr)) {
@@ -151650,9 +151648,9 @@ function* generate(func) {
   const returnTypes = [];
   for (const [_, block] of func.body.blocks) {
     for (const phi of block.phis) {
-      yield equation(phi.id.type, {
+      yield equation(phi.place.identifier.type, {
         kind: 'Phi',
-        operands: [...phi.operands.values()].map(id => id.type),
+        operands: [...phi.operands.values()].map(id => id.identifier.type),
       });
     }
     for (const instr of block.instructions) {
@@ -152321,16 +152319,17 @@ function validateHooksUsage(fn) {
   for (const [, block] of fn.body.blocks) {
     for (const phi of block.phis) {
       let kind =
-        phi.id.name !== null && isHookName$1(phi.id.name.value)
+        phi.place.identifier.name !== null &&
+        isHookName$1(phi.place.identifier.name.value)
           ? Kind.PotentialHook
           : Kind.Local;
       for (const [, operand] of phi.operands) {
-        const operandKind = valueKinds.get(operand.id);
+        const operandKind = valueKinds.get(operand.identifier.id);
         if (operandKind !== undefined) {
           kind = joinKinds(kind, operandKind);
         }
       }
-      valueKinds.set(phi.id.id, kind);
+      valueKinds.set(phi.place.identifier.id, kind);
     }
     for (const instr of block.instructions) {
       switch (instr.value.kind) {
@@ -152664,6 +152663,19 @@ function validateNoCapitalizedCalls(fn) {
   }
 }
 var _Env_changed;
+function makeRefId(id) {
+  CompilerError.invariant(id >= 0 && Number.isInteger(id), {
+    reason: 'Expected identifier id to be a non-negative integer',
+    description: null,
+    loc: null,
+    suggestions: null,
+  });
+  return id;
+}
+let _refId = 0;
+function nextRefId() {
+  return makeRefId(_refId++);
+}
 class Env extends Map {
   constructor() {
     super(...arguments);
@@ -152695,11 +152707,11 @@ function validateNoRefAccessInRender(fn) {
   const env = new Env();
   validateNoRefAccessInRenderImpl(fn, env).unwrap();
 }
-function refTypeOfType(identifier) {
-  if (isRefValueType(identifier)) {
+function refTypeOfType(place) {
+  if (isRefValueType(place.identifier)) {
     return {kind: 'RefValue'};
-  } else if (isUseRefType(identifier)) {
-    return {kind: 'Ref'};
+  } else if (isUseRefType(place.identifier)) {
+    return {kind: 'Ref', refId: nextRefId()};
   } else {
     return {kind: 'None'};
   }
@@ -152713,6 +152725,14 @@ function tyEqual(a, b) {
       return true;
     case 'Ref':
       return true;
+    case 'Nullable':
+      return true;
+    case 'Guard':
+      CompilerError.invariant(b.kind === 'Guard', {
+        reason: 'Expected ref value',
+        loc: null,
+      });
+      return a.refId === b.refId;
     case 'RefValue':
       CompilerError.invariant(b.kind === 'RefValue', {
         reason: 'Expected ref value',
@@ -152741,11 +152761,17 @@ function tyEqual(a, b) {
 function joinRefAccessTypes(...types) {
   function joinRefAccessRefTypes(a, b) {
     if (a.kind === 'RefValue') {
-      return a;
+      if (b.kind === 'RefValue' && a.refId === b.refId) {
+        return a;
+      }
+      return {kind: 'RefValue'};
     } else if (b.kind === 'RefValue') {
       return b;
     } else if (a.kind === 'Ref' || b.kind === 'Ref') {
-      return {kind: 'Ref'};
+      if (a.kind === 'Ref' && b.kind === 'Ref' && a.refId === b.refId) {
+        return a;
+      }
+      return {kind: 'Ref', refId: nextRefId()};
     } else {
       CompilerError.invariant(
         a.kind === 'Structure' && b.kind === 'Structure',
@@ -152778,6 +152804,16 @@ function joinRefAccessTypes(...types) {
         return b;
       } else if (b.kind === 'None') {
         return a;
+      } else if (a.kind === 'Guard' || b.kind === 'Guard') {
+        if (a.kind === 'Guard' && b.kind === 'Guard' && a.refId === b.refId) {
+          return a;
+        }
+        return {kind: 'None'};
+      } else if (a.kind === 'Nullable' || b.kind === 'Nullable') {
+        if (a.kind === 'Nullable' && b.kind === 'Nullable') {
+          return a;
+        }
+        return {kind: 'None'};
       } else {
         return joinRefAccessRefTypes(a, b);
       }
@@ -152786,7 +152822,7 @@ function joinRefAccessTypes(...types) {
   );
 }
 function validateNoRefAccessInRenderImpl(fn, env) {
-  var _a, _b, _c, _d, _e, _f;
+  var _a, _b, _c, _d, _e, _f, _g, _h;
   let returnValues = [];
   let place;
   for (const param of fn.params) {
@@ -152795,21 +152831,23 @@ function validateNoRefAccessInRenderImpl(fn, env) {
     } else {
       place = param.place;
     }
-    const type = refTypeOfType(place.identifier);
+    const type = refTypeOfType(place);
     env.set(place.identifier.id, type);
   }
   for (let i = 0; (i == 0 || env.hasChanged()) && i < 10; i++) {
     env.resetChanged();
     returnValues = [];
+    const safeBlocks = new Map();
     const errors = new CompilerError();
     for (const [, block] of fn.body.blocks) {
       for (const phi of block.phis) {
         env.set(
-          phi.id.id,
+          phi.place.identifier.id,
           joinRefAccessTypes(
             ...Array(...phi.operands.values()).map(operand => {
               var _a;
-              return (_a = env.get(operand.id)) !== null && _a !== void 0
+              return (_a = env.get(operand.identifier.id)) !== null &&
+                _a !== void 0
                 ? _a
                 : {kind: 'None'};
             })
@@ -152843,13 +152881,17 @@ function validateNoRefAccessInRenderImpl(fn, env) {
                 ? void 0
                 : objType.kind) === 'Ref'
             ) {
-              lookupType = {kind: 'RefValue', loc: instr.loc};
+              lookupType = {
+                kind: 'RefValue',
+                loc: instr.loc,
+                refId: objType.refId,
+              };
             }
             env.set(
               instr.lvalue.identifier.id,
               lookupType !== null && lookupType !== void 0
                 ? lookupType
-                : refTypeOfType(instr.lvalue.identifier)
+                : refTypeOfType(instr.lvalue)
             );
             break;
           }
@@ -152860,7 +152902,7 @@ function validateNoRefAccessInRenderImpl(fn, env) {
               (_a = env.get(instr.value.place.identifier.id)) !== null &&
                 _a !== void 0
                 ? _a
-                : refTypeOfType(instr.lvalue.identifier)
+                : refTypeOfType(instr.lvalue)
             );
             break;
           }
@@ -152871,14 +152913,14 @@ function validateNoRefAccessInRenderImpl(fn, env) {
               (_b = env.get(instr.value.value.identifier.id)) !== null &&
                 _b !== void 0
                 ? _b
-                : refTypeOfType(instr.value.lvalue.place.identifier)
+                : refTypeOfType(instr.value.lvalue.place)
             );
             env.set(
               instr.lvalue.identifier.id,
               (_c = env.get(instr.value.value.identifier.id)) !== null &&
                 _c !== void 0
                 ? _c
-                : refTypeOfType(instr.lvalue.identifier)
+                : refTypeOfType(instr.lvalue)
             );
             break;
           }
@@ -152896,14 +152938,14 @@ function validateNoRefAccessInRenderImpl(fn, env) {
               instr.lvalue.identifier.id,
               lookupType !== null && lookupType !== void 0
                 ? lookupType
-                : refTypeOfType(instr.lvalue.identifier)
+                : refTypeOfType(instr.lvalue)
             );
             for (const lval of eachPatternOperand(instr.value.lvalue.pattern)) {
               env.set(
                 lval.identifier.id,
                 lookupType !== null && lookupType !== void 0
                   ? lookupType
-                  : refTypeOfType(lval.identifier)
+                  : refTypeOfType(lval)
               );
             }
             break;
@@ -152980,7 +153022,11 @@ function validateNoRefAccessInRenderImpl(fn, env) {
               );
             }
             const value = joinRefAccessTypes(...types);
-            if (value.kind === 'None') {
+            if (
+              value.kind === 'None' ||
+              value.kind === 'Guard' ||
+              value.kind === 'Nullable'
+            ) {
               env.set(instr.lvalue.identifier.id, {kind: 'None'});
             } else {
               env.set(instr.lvalue.identifier.id, {
@@ -152995,7 +153041,19 @@ function validateNoRefAccessInRenderImpl(fn, env) {
           case 'PropertyStore':
           case 'ComputedDelete':
           case 'ComputedStore': {
-            validateNoRefAccess(errors, env, instr.value.object, instr.loc);
+            const safe = safeBlocks.get(block.id);
+            const target = env.get(instr.value.object.identifier.id);
+            if (
+              instr.value.kind === 'PropertyStore' &&
+              safe != null &&
+              (target === null || target === void 0 ? void 0 : target.kind) ===
+                'Ref' &&
+              target.refId === safe
+            ) {
+              safeBlocks.delete(block.id);
+            } else {
+              validateNoRefAccess(errors, env, instr.value.object, instr.loc);
+            }
             for (const operand of eachInstructionValueOperand(instr.value)) {
               if (operand === instr.value.object) {
                 continue;
@@ -153007,6 +153065,53 @@ function validateNoRefAccessInRenderImpl(fn, env) {
           case 'StartMemoize':
           case 'FinishMemoize':
             break;
+          case 'Primitive': {
+            if (instr.value.value == null) {
+              env.set(instr.lvalue.identifier.id, {kind: 'Nullable'});
+            }
+            break;
+          }
+          case 'BinaryExpression': {
+            const left = env.get(instr.value.left.identifier.id);
+            const right = env.get(instr.value.right.identifier.id);
+            let nullish = false;
+            let refId = null;
+            if (
+              (left === null || left === void 0 ? void 0 : left.kind) ===
+                'RefValue' &&
+              left.refId != null
+            ) {
+              refId = left.refId;
+            } else if (
+              (right === null || right === void 0 ? void 0 : right.kind) ===
+                'RefValue' &&
+              right.refId != null
+            ) {
+              refId = right.refId;
+            }
+            if (
+              (left === null || left === void 0 ? void 0 : left.kind) ===
+              'Nullable'
+            ) {
+              nullish = true;
+            } else if (
+              (right === null || right === void 0 ? void 0 : right.kind) ===
+              'Nullable'
+            ) {
+              nullish = true;
+            }
+            if (refId !== null && nullish) {
+              env.set(instr.lvalue.identifier.id, {
+                kind: 'Guard',
+                refId: refId,
+              });
+            } else {
+              for (const operand of eachInstructionValueOperand(instr.value)) {
+                validateNoRefValueAccess(errors, env, operand);
+              }
+            }
+            break;
+          }
           default: {
             for (const operand of eachInstructionValueOperand(instr.value)) {
               validateNoRefValueAccess(errors, env, operand);
@@ -153014,36 +153119,61 @@ function validateNoRefAccessInRenderImpl(fn, env) {
             break;
           }
         }
-        if (isUseRefType(instr.lvalue.identifier)) {
+        for (const operand of eachInstructionOperand(instr)) {
+          guardCheck(errors, operand, env);
+        }
+        if (
+          isUseRefType(instr.lvalue.identifier) &&
+          ((_e = env.get(instr.lvalue.identifier.id)) === null || _e === void 0
+            ? void 0
+            : _e.kind) !== 'Ref'
+        ) {
           env.set(
             instr.lvalue.identifier.id,
             joinRefAccessTypes(
-              (_e = env.get(instr.lvalue.identifier.id)) !== null &&
-                _e !== void 0
-                ? _e
+              (_f = env.get(instr.lvalue.identifier.id)) !== null &&
+                _f !== void 0
+                ? _f
                 : {kind: 'None'},
-              {kind: 'Ref'}
+              {kind: 'Ref', refId: nextRefId()}
             )
           );
         }
-        if (isRefValueType(instr.lvalue.identifier)) {
+        if (
+          isRefValueType(instr.lvalue.identifier) &&
+          ((_g = env.get(instr.lvalue.identifier.id)) === null || _g === void 0
+            ? void 0
+            : _g.kind) !== 'RefValue'
+        ) {
           env.set(
             instr.lvalue.identifier.id,
             joinRefAccessTypes(
-              (_f = env.get(instr.lvalue.identifier.id)) !== null &&
-                _f !== void 0
-                ? _f
+              (_h = env.get(instr.lvalue.identifier.id)) !== null &&
+                _h !== void 0
+                ? _h
                 : {kind: 'None'},
               {kind: 'RefValue', loc: instr.loc}
             )
           );
         }
       }
+      if (block.terminal.kind === 'if') {
+        const test = env.get(block.terminal.test.identifier.id);
+        if (
+          (test === null || test === void 0 ? void 0 : test.kind) === 'Guard'
+        ) {
+          safeBlocks.set(block.terminal.consequent, test.refId);
+        }
+      }
       for (const operand of eachTerminalOperand(block.terminal)) {
         if (block.terminal.kind !== 'return') {
           validateNoRefValueAccess(errors, env, operand);
+          if (block.terminal.kind !== 'if') {
+            guardCheck(errors, operand, env);
+          }
         } else {
           validateNoDirectRefValueAccess(errors, operand, env);
+          guardCheck(errors, operand, env);
           returnValues.push(env.get(operand.identifier.id));
         }
       }
@@ -153069,6 +153199,27 @@ function destructure(type) {
   }
   return type;
 }
+function guardCheck(errors, operand, env) {
+  var _a;
+  if (
+    ((_a = env.get(operand.identifier.id)) === null || _a === void 0
+      ? void 0
+      : _a.kind) === 'Guard'
+  ) {
+    errors.push({
+      severity: exports.ErrorSeverity.InvalidReact,
+      reason:
+        'Ref values (the `current` property) may not be accessed during render. (https://react.dev/reference/react/useRef)',
+      loc: operand.loc,
+      description:
+        operand.identifier.name !== null &&
+        operand.identifier.name.kind === 'named'
+          ? `Cannot access ref value \`${operand.identifier.name.value}\``
+          : null,
+      suggestions: null,
+    });
+  }
+}
 function validateNoRefValueAccess(errors, env, operand) {
   var _a;
   const type = destructure(env.get(operand.identifier.id));
@@ -153876,21 +154027,24 @@ function propagatePhiTypes(fn) {
   const propagated = new Set();
   for (const [, block] of fn.body.blocks) {
     for (const phi of block.phis) {
-      if (phi.id.type.kind !== 'Type' || phi.id.name !== null) {
+      if (
+        phi.place.identifier.type.kind !== 'Type' ||
+        phi.place.identifier.name !== null
+      ) {
         continue;
       }
       let type = null;
       for (const [, operand] of phi.operands) {
         if (type === null) {
-          type = operand.type;
-        } else if (!typeEquals(type, operand.type)) {
+          type = operand.identifier.type;
+        } else if (!typeEquals(type, operand.identifier.type)) {
           type = null;
           break;
         }
       }
       if (type !== null) {
-        phi.id.type = type;
-        propagated.add(phi.id.id);
+        phi.place.identifier.type = type;
+        propagated.add(phi.place.identifier.id);
       }
     }
     for (const instr of block.instructions) {
@@ -155546,7 +155700,7 @@ function collectDependencies(
     }
     for (const phi of block.phis) {
       for (const operand of phi.operands) {
-        const maybeOptionalChain = temporaries.get(operand[1].id);
+        const maybeOptionalChain = temporaries.get(operand[1].identifier.id);
         if (maybeOptionalChain) {
           context.visitDependency(maybeOptionalChain);
         }