babel-plugin-react-compiler 0.0.0-experimental-23b8160-20240916 → 0.0.0-experimental-ca8e0be-20240916

package/dist/index.js

@@ -139601,6 +139601,8 @@ var InstructionKind;
   InstructionKind['Catch'] = 'Catch';
   InstructionKind['HoistedConst'] = 'HoistedConst';
   InstructionKind['HoistedLet'] = 'HoistedLet';
+  InstructionKind['HoistedFunction'] = 'HoistedFunction';
+  InstructionKind['Function'] = 'Function';
 })(InstructionKind || (InstructionKind = {}));
 function makeTemporaryIdentifier(id, loc) {
   return {
@@ -144017,7 +144019,14 @@ function lowerStatement(builder, stmtPath, label = null) {
           if (builder.environment.isHoistedIdentifier(binding.identifier)) {
             continue;
           }
-          if (!binding.path.isVariableDeclarator()) {
+          let kind;
+          if (binding.kind === 'const' || binding.kind === 'var') {
+            kind = InstructionKind.HoistedConst;
+          } else if (binding.kind === 'let') {
+            kind = InstructionKind.HoistedLet;
+          } else if (binding.path.isFunctionDeclaration()) {
+            kind = InstructionKind.HoistedFunction;
+          } else if (!binding.path.isVariableDeclarator()) {
             builder.errors.push({
               severity: exports.ErrorSeverity.Todo,
               reason: 'Unsupported declaration type for hoisting',
@@ -144029,11 +144038,7 @@ function lowerStatement(builder, stmtPath, label = null) {
                   : GeneratedSource,
             });
             continue;
-          } else if (
-            binding.kind !== 'const' &&
-            binding.kind !== 'var' &&
-            binding.kind !== 'let'
-          ) {
+          } else {
             builder.errors.push({
               severity: exports.ErrorSeverity.Todo,
               reason: 'Handle non-const declarations for hoisting',
@@ -144065,12 +144070,6 @@ function lowerStatement(builder, stmtPath, label = null) {
                 ? _j
                 : GeneratedSource,
           };
-          const kind =
-            binding.kind === 'const' || binding.kind === 'var'
-              ? InstructionKind.HoistedConst
-              : binding.kind === 'let'
-                ? InstructionKind.HoistedLet
-                : assertExhaustive(binding.kind, 'Unexpected binding kind');
           lowerValueToTemporary(builder, {
             kind: 'DeclareContext',
             lvalue: {kind: kind, place: place},
@@ -144615,7 +144614,7 @@ function lowerStatement(builder, stmtPath, label = null) {
         (_10 = stmt.node.loc) !== null && _10 !== void 0
           ? _10
           : GeneratedSource,
-        InstructionKind.Let,
+        InstructionKind.Function,
         id,
         fn,
         'Assignment'
@@ -150159,6 +150158,17 @@ const REACT_APIS = [
       returnValueKind: exports.ValueKind.Mutable,
     }),
   ],
+  [
+    'useImperativeHandle',
+    addHook(DEFAULT_SHAPES, {
+      positionalParams: [],
+      restParam: exports.Effect.Freeze,
+      returnType: {kind: 'Primitive'},
+      calleeEffect: exports.Effect.Read,
+      hookKind: 'useImperativeHandle',
+      returnValueKind: exports.ValueKind.Frozen,
+    }),
+  ],
   [
     'useMemo',
     addHook(DEFAULT_SHAPES, {
@@ -157991,22 +158001,12 @@ function codegenTerminal(cx, terminal) {
             suggestions: null,
           });
         case InstructionKind.Catch:
-          CompilerError.invariant(false, {
-            reason: 'Unexpected catch variable as for..in collection',
-            description: null,
-            loc: iterableItem.loc,
-            suggestions: null,
-          });
         case InstructionKind.HoistedConst:
-          CompilerError.invariant(false, {
-            reason: 'Unexpected HoistedConst variable in for..in collection',
-            description: null,
-            loc: iterableItem.loc,
-            suggestions: null,
-          });
         case InstructionKind.HoistedLet:
+        case InstructionKind.HoistedFunction:
+        case InstructionKind.Function:
           CompilerError.invariant(false, {
-            reason: 'Unexpected HoistedLet variable in for..in collection',
+            reason: `Unexpected ${iterableItem.value.lvalue.kind} variable in for..in collection`,
             description: null,
             loc: iterableItem.loc,
             suggestions: null,
@@ -158080,30 +158080,13 @@ function codegenTerminal(cx, terminal) {
           varDeclKind = 'let';
           break;
         case InstructionKind.Reassign:
-          CompilerError.invariant(false, {
-            reason:
-              'Destructure should never be Reassign as it would be an Object/ArrayPattern',
-            description: null,
-            loc: iterableItem.loc,
-            suggestions: null,
-          });
         case InstructionKind.Catch:
-          CompilerError.invariant(false, {
-            reason: 'Unexpected catch variable as for..of collection',
-            description: null,
-            loc: iterableItem.loc,
-            suggestions: null,
-          });
         case InstructionKind.HoistedConst:
-          CompilerError.invariant(false, {
-            reason: 'Unexpected HoistedConst variable in for..of collection',
-            description: null,
-            loc: iterableItem.loc,
-            suggestions: null,
-          });
         case InstructionKind.HoistedLet:
+        case InstructionKind.HoistedFunction:
+        case InstructionKind.Function:
           CompilerError.invariant(false, {
-            reason: 'Unexpected HoistedLet variable in for..of collection',
+            reason: `Unexpected ${iterableItem.value.lvalue.kind} variable in for..of collection`,
             description: null,
             loc: iterableItem.loc,
             suggestions: null,
@@ -158262,6 +158245,39 @@ function codegenInstructionNullable(cx, instr) {
           t__namespace.variableDeclarator(codegenLValue(cx, lvalue), value),
         ]);
       }
+      case InstructionKind.Function: {
+        CompilerError.invariant(instr.lvalue === null, {
+          reason: `Function declaration cannot be referenced as an expression`,
+          description: null,
+          loc: instr.value.loc,
+          suggestions: null,
+        });
+        const genLvalue = codegenLValue(cx, lvalue);
+        CompilerError.invariant(genLvalue.type === 'Identifier', {
+          reason: 'Expected an identifier as a function declaration lvalue',
+          description: null,
+          loc: instr.value.loc,
+          suggestions: null,
+        });
+        CompilerError.invariant(
+          (value === null || value === void 0 ? void 0 : value.type) ===
+            'FunctionExpression',
+          {
+            reason: 'Expected a function as a function declaration value',
+            description: null,
+            loc: instr.value.loc,
+            suggestions: null,
+          }
+        );
+        return createFunctionDeclaration(
+          instr.loc,
+          genLvalue,
+          value.params,
+          value.body,
+          value.generator,
+          value.async
+        );
+      }
       case InstructionKind.Let: {
         CompilerError.invariant(instr.lvalue === null, {
           reason: `Const declaration cannot be referenced as an expression`,
@@ -158303,19 +158319,11 @@ function codegenInstructionNullable(cx, instr) {
       case InstructionKind.Catch: {
         return t__namespace.emptyStatement();
       }
-      case InstructionKind.HoistedLet: {
+      case InstructionKind.HoistedLet:
+      case InstructionKind.HoistedConst:
+      case InstructionKind.HoistedFunction: {
         CompilerError.invariant(false, {
-          reason:
-            'Expected HoistedLet to have been pruned in PruneHoistedContexts',
-          description: null,
-          loc: instr.loc,
-          suggestions: null,
-        });
-      }
-      case InstructionKind.HoistedConst: {
-        CompilerError.invariant(false, {
-          reason:
-            'Expected HoistedConsts to have been pruned in PruneHoistedContexts',
+          reason: `Expected ${kind} to have been pruned in PruneHoistedContexts`,
           description: null,
           loc: instr.loc,
           suggestions: null,
@@ -158463,6 +158471,7 @@ function withLoc(fn) {
 const createBinaryExpression = withLoc(t__namespace.binaryExpression);
 const createExpressionStatement = withLoc(t__namespace.expressionStatement);
 const createVariableDeclaration = withLoc(t__namespace.variableDeclaration);
+const createFunctionDeclaration = withLoc(t__namespace.functionDeclaration);
 const createTaggedTemplateExpression = withLoc(
   t__namespace.taggedTemplateExpression
 );
@@ -162063,6 +162072,16 @@ let Visitor$8 = class Visitor extends ReactiveFunctionTransform {
       );
       return {kind: 'remove'};
     }
+    if (
+      instruction.value.kind === 'DeclareContext' &&
+      instruction.value.lvalue.kind === 'HoistedFunction'
+    ) {
+      state.set(
+        instruction.value.lvalue.place.identifier.declarationId,
+        InstructionKind.Function
+      );
+      return {kind: 'remove'};
+    }
     if (
       instruction.value.kind === 'StoreContext' &&
       state.has(instruction.value.lvalue.place.identifier.declarationId)
@@ -167172,7 +167191,7 @@ function equation(left, right) {
   return {left: left, right: right};
 }
 function* generate(func) {
-  if (func.env.fnType === 'Component') {
+  if (func.fnType === 'Component') {
     const [props, ref] = func.params;
     if (props && props.kind === 'Identifier') {
       yield equation(props.identifier.type, {
@@ -168204,16 +168223,131 @@ function validateNoCapitalizedCalls(fn) {
     }
   }
 }
+var _Env_changed;
+class Env extends Map {
+  constructor() {
+    super(...arguments);
+    _Env_changed.set(this, false);
+  }
+  resetChanged() {
+    __classPrivateFieldSet(this, _Env_changed, false, 'f');
+  }
+  hasChanged() {
+    return __classPrivateFieldGet(this, _Env_changed, 'f');
+  }
+  set(key, value) {
+    const cur = this.get(key);
+    const widenedValue = joinRefAccessTypes(
+      value,
+      cur !== null && cur !== void 0 ? cur : {kind: 'None'}
+    );
+    if (
+      !(cur == null && widenedValue.kind === 'None') &&
+      (cur == null || !tyEqual(cur, widenedValue))
+    ) {
+      __classPrivateFieldSet(this, _Env_changed, true, 'f');
+    }
+    return super.set(key, widenedValue);
+  }
+}
+_Env_changed = new WeakMap();
 function validateNoRefAccessInRender(fn) {
-  const state = {
-    refs: new Set(),
-    refValues: new Map(),
-    refAccessingFunctions: new Set(),
-  };
-  validateNoRefAccessInRenderImpl(fn, state).unwrap();
+  const env = new Env();
+  validateNoRefAccessInRenderImpl(fn, env).unwrap();
+}
+function refTypeOfType(identifier) {
+  if (isRefValueType(identifier)) {
+    return {kind: 'RefValue'};
+  } else if (isUseRefType(identifier)) {
+    return {kind: 'Ref'};
+  } else {
+    return {kind: 'None'};
+  }
 }
-function validateNoRefAccessInRenderImpl(fn, state) {
-  var _a, _b;
+function tyEqual(a, b) {
+  if (a.kind !== b.kind) {
+    return false;
+  }
+  switch (a.kind) {
+    case 'None':
+      return true;
+    case 'Ref':
+      return true;
+    case 'RefValue':
+      CompilerError.invariant(b.kind === 'RefValue', {
+        reason: 'Expected ref value',
+        loc: null,
+      });
+      return a.loc == b.loc;
+    case 'Structure': {
+      CompilerError.invariant(b.kind === 'Structure', {
+        reason: 'Expected structure',
+        loc: null,
+      });
+      const fnTypesEqual =
+        (a.fn === null && b.fn === null) ||
+        (a.fn !== null &&
+          b.fn !== null &&
+          a.fn.readRefEffect === b.fn.readRefEffect &&
+          tyEqual(a.fn.returnType, b.fn.returnType));
+      return (
+        fnTypesEqual &&
+        (a.value === b.value ||
+          (a.value !== null && b.value !== null && tyEqual(a.value, b.value)))
+      );
+    }
+  }
+}
+function joinRefAccessTypes(...types) {
+  function joinRefAccessRefTypes(a, b) {
+    if (a.kind === 'RefValue') {
+      return a;
+    } else if (b.kind === 'RefValue') {
+      return b;
+    } else if (a.kind === 'Ref' || b.kind === 'Ref') {
+      return {kind: 'Ref'};
+    } else {
+      CompilerError.invariant(
+        a.kind === 'Structure' && b.kind === 'Structure',
+        {reason: 'Expected structure', loc: null}
+      );
+      const fn =
+        a.fn === null
+          ? b.fn
+          : b.fn === null
+            ? a.fn
+            : {
+                readRefEffect: a.fn.readRefEffect || b.fn.readRefEffect,
+                returnType: joinRefAccessTypes(
+                  a.fn.returnType,
+                  b.fn.returnType
+                ),
+              };
+      const value =
+        a.value === null
+          ? b.value
+          : b.value === null
+            ? a.value
+            : joinRefAccessRefTypes(a.value, b.value);
+      return {kind: 'Structure', fn: fn, value: value};
+    }
+  }
+  return types.reduce(
+    (a, b) => {
+      if (a.kind === 'None') {
+        return b;
+      } else if (b.kind === 'None') {
+        return a;
+      } else {
+        return joinRefAccessRefTypes(a, b);
+      }
+    },
+    {kind: 'None'}
+  );
+}
+function validateNoRefAccessInRenderImpl(fn, env) {
+  var _a, _b, _c, _d, _e, _f;
+  let returnValues = [];
   let place;
   for (const param of fn.params) {
     if (param.kind === 'Identifier') {
@@ -168221,291 +168355,293 @@ function validateNoRefAccessInRenderImpl(fn, state) {
     } else {
       place = param.place;
     }
-    if (isRefValueType(place.identifier)) {
-      state.refValues.set(place.identifier.id, null);
-    }
-    if (isUseRefType(place.identifier)) {
-      state.refs.add(place.identifier.id);
-    }
+    const type = refTypeOfType(place.identifier);
+    env.set(place.identifier.id, type);
   }
-  const errors = new CompilerError();
-  for (const [, block] of fn.body.blocks) {
-    for (const phi of block.phis) {
-      phi.operands.forEach(operand => {
-        var _a;
-        if (state.refs.has(operand.id) || isUseRefType(phi.id)) {
-          state.refs.add(phi.id.id);
-        }
-        const refValue = state.refValues.get(operand.id);
-        if (refValue !== undefined || isRefValueType(operand)) {
-          state.refValues.set(
-            phi.id.id,
-            (_a =
-              refValue !== null && refValue !== void 0
-                ? refValue
-                : state.refValues.get(phi.id.id)) !== null && _a !== void 0
-              ? _a
-              : null
-          );
-        }
-        if (state.refAccessingFunctions.has(operand.id)) {
-          state.refAccessingFunctions.add(phi.id.id);
-        }
-      });
-    }
-    for (const instr of block.instructions) {
-      for (const operand of eachInstructionValueOperand(instr.value)) {
-        if (isRefValueType(operand.identifier)) {
-          CompilerError.invariant(state.refValues.has(operand.identifier.id), {
-            reason: 'Expected ref value to be in state',
-            loc: operand.loc,
-          });
-        }
-        if (isUseRefType(operand.identifier)) {
-          CompilerError.invariant(state.refs.has(operand.identifier.id), {
-            reason: 'Expected ref to be in state',
-            loc: operand.loc,
-          });
-        }
+  for (let i = 0; (i == 0 || env.hasChanged()) && i < 10; i++) {
+    env.resetChanged();
+    returnValues = [];
+    const errors = new CompilerError();
+    for (const [, block] of fn.body.blocks) {
+      for (const phi of block.phis) {
+        env.set(
+          phi.id.id,
+          joinRefAccessTypes(
+            ...Array(...phi.operands.values()).map(operand => {
+              var _a;
+              return (_a = env.get(operand.id)) !== null && _a !== void 0
+                ? _a
+                : {kind: 'None'};
+            })
+          )
+        );
       }
-      switch (instr.value.kind) {
-        case 'JsxExpression':
-        case 'JsxFragment': {
-          for (const operand of eachInstructionValueOperand(instr.value)) {
-            validateNoDirectRefValueAccess(errors, operand, state);
-          }
-          break;
-        }
-        case 'ComputedLoad':
-        case 'PropertyLoad': {
-          if (typeof instr.value.property !== 'string') {
-            validateNoRefValueAccess(errors, state, instr.value.property);
-          }
-          if (
-            state.refAccessingFunctions.has(instr.value.object.identifier.id)
-          ) {
-            state.refAccessingFunctions.add(instr.lvalue.identifier.id);
-          }
-          if (state.refs.has(instr.value.object.identifier.id)) {
-            state.refs.add(instr.lvalue.identifier.id);
-            state.refValues.set(instr.lvalue.identifier.id, instr.loc);
-          }
-          break;
-        }
-        case 'LoadContext':
-        case 'LoadLocal': {
-          if (
-            state.refAccessingFunctions.has(instr.value.place.identifier.id)
-          ) {
-            state.refAccessingFunctions.add(instr.lvalue.identifier.id);
-          }
-          const refValue = state.refValues.get(instr.value.place.identifier.id);
-          if (refValue !== undefined) {
-            state.refValues.set(instr.lvalue.identifier.id, refValue);
+      for (const instr of block.instructions) {
+        switch (instr.value.kind) {
+          case 'JsxExpression':
+          case 'JsxFragment': {
+            for (const operand of eachInstructionValueOperand(instr.value)) {
+              validateNoDirectRefValueAccess(errors, operand, env);
+            }
+            break;
           }
-          if (state.refs.has(instr.value.place.identifier.id)) {
-            state.refs.add(instr.lvalue.identifier.id);
+          case 'ComputedLoad':
+          case 'PropertyLoad': {
+            if (typeof instr.value.property !== 'string') {
+              validateNoDirectRefValueAccess(errors, instr.value.property, env);
+            }
+            const objType = env.get(instr.value.object.identifier.id);
+            let lookupType = null;
+            if (
+              (objType === null || objType === void 0
+                ? void 0
+                : objType.kind) === 'Structure'
+            ) {
+              lookupType = objType.value;
+            } else if (
+              (objType === null || objType === void 0
+                ? void 0
+                : objType.kind) === 'Ref'
+            ) {
+              lookupType = {kind: 'RefValue', loc: instr.loc};
+            }
+            env.set(
+              instr.lvalue.identifier.id,
+              lookupType !== null && lookupType !== void 0
+                ? lookupType
+                : refTypeOfType(instr.lvalue.identifier)
+            );
+            break;
           }
-          break;
-        }
-        case 'StoreContext':
-        case 'StoreLocal': {
-          if (
-            state.refAccessingFunctions.has(instr.value.value.identifier.id)
-          ) {
-            state.refAccessingFunctions.add(
-              instr.value.lvalue.place.identifier.id
+          case 'LoadContext':
+          case 'LoadLocal': {
+            env.set(
+              instr.lvalue.identifier.id,
+              (_a = env.get(instr.value.place.identifier.id)) !== null &&
+                _a !== void 0
+                ? _a
+                : refTypeOfType(instr.lvalue.identifier)
             );
-            state.refAccessingFunctions.add(instr.lvalue.identifier.id);
+            break;
           }
-          const refValue = state.refValues.get(instr.value.value.identifier.id);
-          if (
-            refValue !== undefined ||
-            isRefValueType(instr.value.lvalue.place.identifier)
-          ) {
-            state.refValues.set(
+          case 'StoreContext':
+          case 'StoreLocal': {
+            env.set(
               instr.value.lvalue.place.identifier.id,
-              refValue !== null && refValue !== void 0 ? refValue : null
+              (_b = env.get(instr.value.value.identifier.id)) !== null &&
+                _b !== void 0
+                ? _b
+                : refTypeOfType(instr.value.lvalue.place.identifier)
             );
-            state.refValues.set(
+            env.set(
               instr.lvalue.identifier.id,
-              refValue !== null && refValue !== void 0 ? refValue : null
+              (_c = env.get(instr.value.value.identifier.id)) !== null &&
+                _c !== void 0
+                ? _c
+                : refTypeOfType(instr.lvalue.identifier)
             );
+            break;
           }
-          if (state.refs.has(instr.value.value.identifier.id)) {
-            state.refs.add(instr.value.lvalue.place.identifier.id);
-            state.refs.add(instr.lvalue.identifier.id);
-          }
-          break;
-        }
-        case 'Destructure': {
-          const destructuredFunction = state.refAccessingFunctions.has(
-            instr.value.value.identifier.id
-          );
-          const destructuredRef = state.refs.has(
-            instr.value.value.identifier.id
-          );
-          for (const lval of eachPatternOperand(instr.value.lvalue.pattern)) {
-            if (isUseRefType(lval.identifier)) {
-              state.refs.add(lval.identifier.id);
-            }
-            if (destructuredRef || isRefValueType(lval.identifier)) {
-              state.refs.add(lval.identifier.id);
-              state.refValues.set(lval.identifier.id, null);
+          case 'Destructure': {
+            const objType = env.get(instr.value.value.identifier.id);
+            let lookupType = null;
+            if (
+              (objType === null || objType === void 0
+                ? void 0
+                : objType.kind) === 'Structure'
+            ) {
+              lookupType = objType.value;
             }
-            if (destructuredFunction) {
-              state.refAccessingFunctions.add(lval.identifier.id);
+            env.set(
+              instr.lvalue.identifier.id,
+              lookupType !== null && lookupType !== void 0
+                ? lookupType
+                : refTypeOfType(instr.lvalue.identifier)
+            );
+            for (const lval of eachPatternOperand(instr.value.lvalue.pattern)) {
+              env.set(
+                lval.identifier.id,
+                lookupType !== null && lookupType !== void 0
+                  ? lookupType
+                  : refTypeOfType(lval.identifier)
+              );
             }
+            break;
           }
-          break;
-        }
-        case 'ObjectMethod':
-        case 'FunctionExpression': {
-          if (
-            [...eachInstructionValueOperand(instr.value)].some(
-              operand =>
-                state.refValues.has(operand.identifier.id) ||
-                state.refAccessingFunctions.has(operand.identifier.id)
-            ) ||
-            ([...eachInstructionValueOperand(instr.value)].some(operand =>
-              state.refs.has(operand.identifier.id)
-            ) &&
-              validateNoRefAccessInRenderImpl(
-                instr.value.loweredFunc.func,
-                state
-              ).isErr())
-          ) {
-            state.refAccessingFunctions.add(instr.lvalue.identifier.id);
+          case 'ObjectMethod':
+          case 'FunctionExpression': {
+            let returnType = {kind: 'None'};
+            let readRefEffect = false;
+            const result = validateNoRefAccessInRenderImpl(
+              instr.value.loweredFunc.func,
+              env
+            );
+            if (result.isOk()) {
+              returnType = result.unwrap();
+            } else if (result.isErr()) {
+              readRefEffect = true;
+            }
+            env.set(instr.lvalue.identifier.id, {
+              kind: 'Structure',
+              fn: {readRefEffect: readRefEffect, returnType: returnType},
+              value: null,
+            });
+            break;
           }
-          break;
-        }
-        case 'MethodCall': {
-          if (!isEffectHook(instr.value.property.identifier)) {
+          case 'MethodCall':
+          case 'CallExpression': {
+            const callee =
+              instr.value.kind === 'CallExpression'
+                ? instr.value.callee
+                : instr.value.property;
+            const hookKind = getHookKindForType(fn.env, callee.identifier.type);
+            let returnType = {kind: 'None'};
+            const fnType = env.get(callee.identifier.id);
+            if (
+              (fnType === null || fnType === void 0 ? void 0 : fnType.kind) ===
+                'Structure' &&
+              fnType.fn !== null
+            ) {
+              returnType = fnType.fn.returnType;
+              if (fnType.fn.readRefEffect) {
+                errors.push({
+                  severity: exports.ErrorSeverity.InvalidReact,
+                  reason:
+                    'This function accesses a ref value (the `current` property), which may not be accessed during render. (https://react.dev/reference/react/useRef)',
+                  loc: callee.loc,
+                  description:
+                    callee.identifier.name !== null &&
+                    callee.identifier.name.kind === 'named'
+                      ? `Function \`${callee.identifier.name.value}\` accesses a ref`
+                      : null,
+                  suggestions: null,
+                });
+              }
+            }
             for (const operand of eachInstructionValueOperand(instr.value)) {
-              validateNoRefAccess(errors, state, operand, operand.loc);
+              if (hookKind != null) {
+                validateNoDirectRefValueAccess(errors, operand, env);
+              } else {
+                validateNoRefAccess(errors, env, operand, operand.loc);
+              }
             }
+            env.set(instr.lvalue.identifier.id, returnType);
+            break;
           }
-          break;
-        }
-        case 'CallExpression': {
-          const callee = instr.value.callee;
-          const isUseEffect = isEffectHook(callee.identifier);
-          if (!isUseEffect) {
-            if (state.refAccessingFunctions.has(callee.identifier.id)) {
-              errors.push({
-                severity: exports.ErrorSeverity.InvalidReact,
-                reason:
-                  'This function accesses a ref value (the `current` property), which may not be accessed during render. (https://react.dev/reference/react/useRef)',
-                loc: callee.loc,
-                description:
-                  callee.identifier.name !== null &&
-                  callee.identifier.name.kind === 'named'
-                    ? `Function \`${callee.identifier.name.value}\` accesses a ref`
-                    : null,
-                suggestions: null,
-              });
-            }
+          case 'ObjectExpression':
+          case 'ArrayExpression': {
+            const types = [];
             for (const operand of eachInstructionValueOperand(instr.value)) {
-              validateNoRefAccess(
-                errors,
-                state,
-                operand,
-                (_a = state.refValues.get(operand.identifier.id)) !== null &&
-                  _a !== void 0
-                  ? _a
-                  : operand.loc
+              validateNoDirectRefValueAccess(errors, operand, env);
+              types.push(
+                (_d = env.get(operand.identifier.id)) !== null && _d !== void 0
+                  ? _d
+                  : {kind: 'None'}
               );
             }
-          }
-          break;
-        }
-        case 'ObjectExpression':
-        case 'ArrayExpression': {
-          for (const operand of eachInstructionValueOperand(instr.value)) {
-            validateNoDirectRefValueAccess(errors, operand, state);
-            if (state.refAccessingFunctions.has(operand.identifier.id)) {
-              state.refAccessingFunctions.add(instr.lvalue.identifier.id);
+            const value = joinRefAccessTypes(...types);
+            if (value.kind === 'None') {
+              env.set(instr.lvalue.identifier.id, {kind: 'None'});
+            } else {
+              env.set(instr.lvalue.identifier.id, {
+                kind: 'Structure',
+                value: value,
+                fn: null,
+              });
             }
-            if (state.refs.has(operand.identifier.id)) {
-              state.refs.add(instr.lvalue.identifier.id);
+            break;
+          }
+          case 'PropertyDelete':
+          case 'PropertyStore':
+          case 'ComputedDelete':
+          case 'ComputedStore': {
+            validateNoRefAccess(errors, env, instr.value.object, instr.loc);
+            for (const operand of eachInstructionValueOperand(instr.value)) {
+              if (operand === instr.value.object) {
+                continue;
+              }
+              validateNoRefValueAccess(errors, env, operand);
             }
-            const refValue = state.refValues.get(operand.identifier.id);
-            if (refValue !== undefined) {
-              state.refValues.set(instr.lvalue.identifier.id, refValue);
+            break;
+          }
+          case 'StartMemoize':
+          case 'FinishMemoize':
+            break;
+          default: {
+            for (const operand of eachInstructionValueOperand(instr.value)) {
+              validateNoRefValueAccess(errors, env, operand);
             }
+            break;
           }
-          break;
         }
-        case 'PropertyDelete':
-        case 'PropertyStore':
-        case 'ComputedDelete':
-        case 'ComputedStore': {
-          validateNoRefAccess(
-            errors,
-            state,
-            instr.value.object,
-            (_b = state.refValues.get(instr.value.object.identifier.id)) !==
-              null && _b !== void 0
-              ? _b
-              : instr.loc
+        if (isUseRefType(instr.lvalue.identifier)) {
+          env.set(
+            instr.lvalue.identifier.id,
+            joinRefAccessTypes(
+              (_e = env.get(instr.lvalue.identifier.id)) !== null &&
+                _e !== void 0
+                ? _e
+                : {kind: 'None'},
+              {kind: 'Ref'}
+            )
           );
-          for (const operand of eachInstructionValueOperand(instr.value)) {
-            if (operand === instr.value.object) {
-              continue;
-            }
-            validateNoRefValueAccess(errors, state, operand);
-          }
-          break;
         }
-        case 'StartMemoize':
-        case 'FinishMemoize':
-          break;
-        default: {
-          for (const operand of eachInstructionValueOperand(instr.value)) {
-            validateNoRefValueAccess(errors, state, operand);
-          }
-          break;
+        if (isRefValueType(instr.lvalue.identifier)) {
+          env.set(
+            instr.lvalue.identifier.id,
+            joinRefAccessTypes(
+              (_f = env.get(instr.lvalue.identifier.id)) !== null &&
+                _f !== void 0
+                ? _f
+                : {kind: 'None'},
+              {kind: 'RefValue', loc: instr.loc}
+            )
+          );
         }
       }
-      if (isUseRefType(instr.lvalue.identifier)) {
-        state.refs.add(instr.lvalue.identifier.id);
-      }
-      if (
-        isRefValueType(instr.lvalue.identifier) &&
-        !state.refValues.has(instr.lvalue.identifier.id)
-      ) {
-        state.refValues.set(instr.lvalue.identifier.id, instr.loc);
+      for (const operand of eachTerminalOperand(block.terminal)) {
+        if (block.terminal.kind !== 'return') {
+          validateNoRefValueAccess(errors, env, operand);
+        } else {
+          validateNoDirectRefValueAccess(errors, operand, env);
+          returnValues.push(env.get(operand.identifier.id));
+        }
       }
     }
-    for (const operand of eachTerminalOperand(block.terminal)) {
-      if (block.terminal.kind !== 'return') {
-        validateNoRefValueAccess(errors, state, operand);
-      } else {
-        validateNoDirectRefValueAccess(errors, operand, state);
-      }
+    if (errors.hasErrors()) {
+      return Err(errors);
     }
   }
-  if (errors.hasErrors()) {
-    return Err(errors);
-  } else {
-    return Ok(undefined);
+  CompilerError.invariant(!env.hasChanged(), {
+    reason: 'Ref type environment did not converge',
+    loc: null,
+  });
+  return Ok(
+    joinRefAccessTypes(...returnValues.filter(env => env !== undefined))
+  );
+}
+function destructure(type) {
+  if (
+    (type === null || type === void 0 ? void 0 : type.kind) === 'Structure' &&
+    type.value !== null
+  ) {
+    return destructure(type.value);
   }
+  return type;
 }
-function validateNoRefValueAccess(errors, state, operand) {
+function validateNoRefValueAccess(errors, env, operand) {
   var _a;
+  const type = destructure(env.get(operand.identifier.id));
   if (
-    state.refValues.has(operand.identifier.id) ||
-    state.refAccessingFunctions.has(operand.identifier.id)
+    (type === null || type === void 0 ? void 0 : type.kind) === 'RefValue' ||
+    ((type === null || type === void 0 ? void 0 : type.kind) === 'Structure' &&
+      ((_a = type.fn) === null || _a === void 0 ? void 0 : _a.readRefEffect))
   ) {
     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:
-        (_a = state.refValues.get(operand.identifier.id)) !== null &&
-        _a !== void 0
-          ? _a
-          : operand.loc,
+      loc: (type.kind === 'RefValue' && type.loc) || operand.loc,
       description:
         operand.identifier.name !== null &&
         operand.identifier.name.kind === 'named'
@@ -168515,17 +168651,20 @@ function validateNoRefValueAccess(errors, state, operand) {
     });
   }
 }
-function validateNoRefAccess(errors, state, operand, loc) {
+function validateNoRefAccess(errors, env, operand, loc) {
+  var _a;
+  const type = destructure(env.get(operand.identifier.id));
   if (
-    state.refs.has(operand.identifier.id) ||
-    state.refValues.has(operand.identifier.id) ||
-    state.refAccessingFunctions.has(operand.identifier.id)
+    (type === null || type === void 0 ? void 0 : type.kind) === 'Ref' ||
+    (type === null || type === void 0 ? void 0 : type.kind) === 'RefValue' ||
+    ((type === null || type === void 0 ? void 0 : type.kind) === 'Structure' &&
+      ((_a = type.fn) === null || _a === void 0 ? void 0 : _a.readRefEffect))
   ) {
     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: loc,
+      loc: (type.kind === 'RefValue' && type.loc) || loc,
       description:
         operand.identifier.name !== null &&
         operand.identifier.name.kind === 'named'
@@ -168535,18 +168674,15 @@ function validateNoRefAccess(errors, state, operand, loc) {
     });
   }
 }
-function validateNoDirectRefValueAccess(errors, operand, state) {
+function validateNoDirectRefValueAccess(errors, operand, env) {
   var _a;
-  if (state.refValues.has(operand.identifier.id)) {
+  const type = destructure(env.get(operand.identifier.id));
+  if ((type === null || type === void 0 ? void 0 : type.kind) === 'RefValue') {
     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:
-        (_a = state.refValues.get(operand.identifier.id)) !== null &&
-        _a !== void 0
-          ? _a
-          : operand.loc,
+      loc: (_a = type.loc) !== null && _a !== void 0 ? _a : operand.loc,
       description:
         operand.identifier.name !== null &&
         operand.identifier.name.kind === 'named'