[compiler] Don't outline functions that reference enclosing-function locals

poteto · tejasupmanyu · poteto · commit c871df13a2e4 · 2026-06-17T01:01:31.000-07:00
When the compiled function is itself nested inside a non-compiled function (e.g. a factory, with @compilationMode:"infer"), HIRBuilder resolves free variables against parentFunction.scope.parent, which is the enclosing function's scope rather than the program scope, so the enclosing function's locals are classified as ModuleLocal and lowered as LoadGlobal instead of being captured in the function's context. Such functions looked outlineable (empty context), and outlining hoisted them to module scope where the referenced name is not in scope, throwing a ReferenceError at runtime (#34901). Fix in the outlining candidate check, in both compilers: reject a candidate if it (or a nested function) references a name that does not resolve to a module-scope binding. The TS pass re-resolves LoadGlobal(ModuleLocal)/StoreGlobal names against the scope HIRBuilder resolved against and requires the binding to be at program scope; the Rust lowering records the misclassified names in env.non_module_scope_names for outline_functions to consult, encoding the same decision. Adopts the approach of community PR #36539 with a stricter predicate: binding-identity instead of name lookup (catching shadowed module names), recursion into nested functions, StoreGlobal coverage, and the Rust port. Co-authored-by: tejasupmanyu <tejasupmanyu@users.noreply.github.com>
diff --git a/compiler/crates/react_compiler_hir/src/environment.rs b/compiler/crates/react_compiler_hir/src/environment.rs
@@ -87,6 +87,14 @@ pub struct Environment {
     // Uses u32 to avoid depending on react_compiler_ast types.
     hoisted_identifiers: HashSet<u32>,
 
+    // Names that HIRBuilder classified as ModuleLocal but that resolve to a
+    // binding *between* module scope and the compiled function (e.g. locals of
+    // an enclosing factory function, when the compiled function is nested).
+    // Mirrors what the TS compiler recovers from Babel scope data in
+    // OutlineFunctions: such names are not in scope at module level, so
+    // functions referencing them must not be outlined.
+    pub non_module_scope_names: HashSet<String>,
+
     // Config flags for validation passes (kept for backwards compat with existing pipeline code)
     pub validate_preserve_existing_memoization_guarantees: bool,
     pub validate_no_set_state_in_render: bool,
@@ -192,6 +200,7 @@ impl Environment {
             renames: Vec::new(),
             reference_node_ids: HashSet::new(),
             hoisted_identifiers: HashSet::new(),
+            non_module_scope_names: HashSet::new(),
             validate_preserve_existing_memoization_guarantees: config
                 .validate_preserve_existing_memoization_guarantees,
             validate_no_set_state_in_render: config.validate_no_set_state_in_render,
@@ -239,6 +248,7 @@ impl Environment {
             renames: Vec::new(),
             reference_node_ids: HashSet::new(),
             hoisted_identifiers: HashSet::new(),
+            non_module_scope_names: self.non_module_scope_names.clone(),
             validate_preserve_existing_memoization_guarantees: self
                 .validate_preserve_existing_memoization_guarantees,
             validate_no_set_state_in_render: self.validate_no_set_state_in_render,
diff --git a/compiler/crates/react_compiler_lowering/src/hir_builder.rs b/compiler/crates/react_compiler_lowering/src/hir_builder.rs
@@ -1026,6 +1026,12 @@ impl<'a> HirBuilder<'a> {
                         },
                     })
                 } else if !self.is_scope_within_compiled_function(binding.scope) {
+                    // The binding lives between module scope and the compiled
+                    // function (e.g. a local of an enclosing factory function).
+                    // It lowers like a module-level binding, but record it so
+                    // outline_functions doesn't hoist references to it out of
+                    // the enclosing function's scope.
+                    self.env.non_module_scope_names.insert(name.to_string());
                     Ok(VariableBinding::ModuleLocal {
                         name: name.to_string(),
                     })
diff --git a/compiler/crates/react_compiler_optimization/src/outline_functions.rs b/compiler/crates/react_compiler_optimization/src/outline_functions.rs
@@ -54,9 +54,11 @@ pub fn outline_functions(
                     // 1. No captured context variables
                     // 2. Anonymous (no explicit id on the inner function)
                     // 3. Not an fbt operand
+                    // 4. Only references names that are in scope at module level
                     if inner_func.context.is_empty()
                         && inner_func.id.is_none()
                         && !fbt_operands.contains(&lvalue_id)
+                        && !references_non_module_scope_bindings(inner_func, env)
                     {
                         actions.push(Action::RecurseAndOutline {
                             instr_idx: instr_id.0 as usize,
@@ -126,3 +128,45 @@ pub fn outline_functions(
         }
     }
 }
+
+/// Returns true if `func` (or a function nested within it) references a
+/// binding that would not be in scope at module level, in which case the
+/// function cannot be outlined.
+///
+/// Ported from TS `referencesNonModuleScopeBindings` in
+/// `Optimization/OutlineFunctions.ts`. The TS implementation re-resolves
+/// each `LoadGlobal(ModuleLocal)`/`StoreGlobal` name against Babel scope
+/// data; the Rust lowering instead records the misclassified names in
+/// `env.non_module_scope_names` as it resolves identifiers (see
+/// `HirBuilder::resolve_identifier`), which encodes the same fact: the name
+/// resolves to a binding *between* module scope and the compiled function
+/// (e.g. a local of an enclosing factory function). Hoisting a function that
+/// references such a name would move the reference out of the enclosing
+/// function's scope and throw a ReferenceError at runtime.
+fn references_non_module_scope_bindings(func: &HirFunction, env: &Environment) -> bool {
+    for block in func.body.blocks.values() {
+        for &instr_id in &block.instructions {
+            let instr = &func.instructions[instr_id.0 as usize];
+            match &instr.value {
+                InstructionValue::LoadGlobal {
+                    binding: NonLocalBinding::ModuleLocal { name },
+                    ..
+                }
+                | InstructionValue::StoreGlobal { name, .. } => {
+                    if env.non_module_scope_names.contains(name) {
+                        return true;
+                    }
+                }
+                InstructionValue::FunctionExpression { lowered_func, .. }
+                | InstructionValue::ObjectMethod { lowered_func, .. } => {
+                    let inner = &env.functions[lowered_func.func.0 as usize];
+                    if references_non_module_scope_bindings(inner, env) {
+                        return true;
+                    }
+                }
+                _ => {}
+            }
+        }
+    }
+    false
+}
diff --git a/compiler/packages/babel-plugin-react-compiler/src/Optimization/OutlineFunctions.ts b/compiler/packages/babel-plugin-react-compiler/src/Optimization/OutlineFunctions.ts
@@ -27,7 +27,8 @@ export function outlineFunctions(
         value.loweredFunc.func.context.length === 0 &&
         // TODO: handle outlining named functions
         value.loweredFunc.func.id === null &&
-        !fbtOperands.has(lvalue.identifier.id)
+        !fbtOperands.has(lvalue.identifier.id) &&
+        !referencesNonModuleScopeBindings(value.loweredFunc.func)
       ) {
         const loweredFunc = value.loweredFunc.func;
 
@@ -49,3 +50,54 @@ export function outlineFunctions(
     }
   }
 }
+
+/**
+ * Returns true if `fn` (or a function nested within it) references a binding
+ * that would not be in scope at module level, in which case the function
+ * cannot be outlined.
+ *
+ * When the function being compiled is itself nested inside another,
+ * non-compiled function (eg a factory in `infer` compilation mode), HIRBuilder
+ * classifies references to the enclosing function's locals as ModuleLocal:
+ * it only distinguishes bindings inside the compiled function from bindings
+ * above it, not module-scope bindings from enclosing-function locals (see
+ * `resolveIdentifier`). Such variables don't appear in `context`, so the
+ * function looks outlineable, but hoisting it to module scope would move the
+ * reference out of the enclosing function's scope and throw a ReferenceError
+ * at runtime. The same applies to StoreGlobal, which records reassignments
+ * of any non-local name.
+ *
+ * Re-resolving the name against the scope enclosing the compiled function —
+ * the same scope HIRBuilder resolved against — tells us which case we're in.
+ * Names that don't resolve to any binding (ambient globals and references to
+ * already-outlined functions) are fine: they mean the same thing at module
+ * scope.
+ */
+function referencesNonModuleScopeBindings(fn: HIRFunction): boolean {
+  const enclosingScope = fn.env.parentFunction.scope.parent;
+  const moduleScope = fn.env.parentFunction.scope.getProgramParent();
+  for (const [, block] of fn.body.blocks) {
+    for (const instr of block.instructions) {
+      const {value} = instr;
+      let name: string | null = null;
+      if (value.kind === 'LoadGlobal' && value.binding.kind === 'ModuleLocal') {
+        name = value.binding.name;
+      } else if (value.kind === 'StoreGlobal') {
+        name = value.name;
+      } else if (
+        (value.kind === 'FunctionExpression' ||
+          value.kind === 'ObjectMethod') &&
+        referencesNonModuleScopeBindings(value.loweredFunc.func)
+      ) {
+        return true;
+      }
+      if (name !== null) {
+        const binding = enclosingScope.getBinding(name);
+        if (binding != null && binding.scope !== moduleScope) {
+          return true;
+        }
+      }
+    }
+  }
+  return false;
+}
diff --git a/compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/outline-function-references-module-const.expect.md b/compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/outline-function-references-module-const.expect.md
@@ -6,8 +6,9 @@
 import {useIdentity} from 'shared-runtime';
 import {Stringify} from 'shared-runtime';
 
+const store = {value: 'hello'};
+
 function createSomething() {
-  const store = {value: 'hello'};
   const Cmp = () => {
     const getStore = useIdentity(() => store);
     return <Stringify result={getStore()} />;
@@ -35,8 +36,9 @@ import { c as _c } from "react/compiler-runtime"; // @compilationMode:"infer"
 import { useIdentity } from "shared-runtime";
 import { Stringify } from "shared-runtime";
 
+const store = { value: "hello" };
+
 function createSomething() {
-  const store = { value: "hello" };
   const Cmp = () => {
     const $ = _c(4);
     const getStore = useIdentity(_temp);
@@ -85,4 +87,6 @@ function _temp() {
 }
 
 ```
-      
+      
+### Eval output
+(kind: ok) <div>{"result":{"value":"hello"}}</div>
diff --git a/compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/outline-function-references-module-const.js b/compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/outline-function-references-module-const.js
@@ -0,0 +1,24 @@
+// @compilationMode:"infer"
+import {useIdentity} from 'shared-runtime';
+import {Stringify} from 'shared-runtime';
+
+const store = {value: 'hello'};
+
+function createSomething() {
+  const Cmp = () => {
+    const getStore = useIdentity(() => store);
+    return <Stringify result={getStore()} />;
+  };
+  return Cmp;
+}
+
+const Thing = createSomething();
+
+function Component() {
+  return <Thing />;
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: Component,
+  params: [{}],
+};
diff --git a/compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/outlined-function-captures-local.expect.md b/compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/outlined-function-captures-local.expect.md
@@ -0,0 +1,94 @@
+
+## Input
+
+```javascript
+// @compilationMode:"infer"
+import {useIdentity} from 'shared-runtime';
+import {Stringify} from 'shared-runtime';
+
+function createSomething() {
+  const store = {value: 'hello'};
+  const Cmp = () => {
+    const getStore = useIdentity(() => store);
+    return <Stringify result={getStore()} />;
+  };
+  return Cmp;
+}
+
+const Thing = createSomething();
+
+function Component() {
+  return <Thing />;
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: Component,
+  params: [{}],
+};
+
+```
+
+## Code
+
+```javascript
+import { c as _c } from "react/compiler-runtime"; // @compilationMode:"infer"
+import { useIdentity } from "shared-runtime";
+import { Stringify } from "shared-runtime";
+
+function createSomething() {
+  const store = { value: "hello" };
+  const Cmp = () => {
+    const $ = _c(5);
+    let t0;
+    if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+      t0 = () => store;
+      $[0] = t0;
+    } else {
+      t0 = $[0];
+    }
+    const getStore = useIdentity(t0);
+    let t1;
+    if ($[1] !== getStore) {
+      t1 = getStore();
+      $[1] = getStore;
+      $[2] = t1;
+    } else {
+      t1 = $[2];
+    }
+    let t2;
+    if ($[3] !== t1) {
+      t2 = <Stringify result={t1} />;
+      $[3] = t1;
+      $[4] = t2;
+    } else {
+      t2 = $[4];
+    }
+    return t2;
+  };
+
+  return Cmp;
+}
+
+const Thing = createSomething();
+
+function Component() {
+  const $ = _c(1);
+  let t0;
+  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+    t0 = <Thing />;
+    $[0] = t0;
+  } else {
+    t0 = $[0];
+  }
+  return t0;
+}
+
+export const FIXTURE_ENTRYPOINT = {
+  fn: Component,
+  params: [{}],
+};
+
+```
+      
+### Eval output
+(kind: ok) <div>{"result":{"value":"hello"}}</div>
diff --git a/compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/outlined-function-captures-local.js b/compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/outlined-function-captures-local.js
diff --git a/compiler/packages/snap/src/SproutTodoFilter.ts b/compiler/packages/snap/src/SproutTodoFilter.ts
@@ -6,12 +6,6 @@
  */
 
 const skipFilter = new Set([
-  /**
-   * Known-bug fixtures documenting wrong runtime behavior; remove each entry
-   * when its fix lands.
-   */
-  'bug-outlined-function-captures-local',
-
   /**
    * Fixtures using external modules (jest, Lexical, etc.) that can't be evaluated
    * in the test harness. These were previously error.todo-* but now compile in both TS and Rust.
