babel-plugin-react-compiler 0.0.0-experimental-afa1d5a-20250319 → 0.0.0-experimental-3452ff1-20250321

package/dist/index.d.ts

@@ -4,6 +4,65 @@ import * as t from '@babel/types';
 import { z } from 'zod';
 import { Scope, NodePath } from '@babel/traverse';
 
+interface Result<T, E> {
+    map<U>(fn: (val: T) => U): Result<U, E>;
+    mapErr<F>(fn: (val: E) => F): Result<T, F>;
+    mapOr<U>(fallback: U, fn: (val: T) => U): U;
+    mapOrElse<U>(fallback: () => U, fn: (val: T) => U): U;
+    andThen<U>(fn: (val: T) => Result<U, E>): Result<U, E>;
+    and<U>(res: Result<U, E>): Result<U, E>;
+    or(res: Result<T, E>): Result<T, E>;
+    orElse<F>(fn: (val: E) => Result<T, F>): Result<T, F>;
+    isOk(): this is OkImpl<T>;
+    isErr(): this is ErrImpl<E>;
+    expect(msg: string): T;
+    expectErr(msg: string): E;
+    unwrap(): T;
+    unwrapOr(fallback: T): T;
+    unwrapOrElse(fallback: (val: E) => T): T;
+    unwrapErr(): E;
+}
+declare class OkImpl<T> implements Result<T, never> {
+    private val;
+    constructor(val: T);
+    map<U>(fn: (val: T) => U): Result<U, never>;
+    mapErr<F>(_fn: (val: never) => F): Result<T, F>;
+    mapOr<U>(_fallback: U, fn: (val: T) => U): U;
+    mapOrElse<U>(_fallback: () => U, fn: (val: T) => U): U;
+    andThen<U>(fn: (val: T) => Result<U, never>): Result<U, never>;
+    and<U>(res: Result<U, never>): Result<U, never>;
+    or(_res: Result<T, never>): Result<T, never>;
+    orElse<F>(_fn: (val: never) => Result<T, F>): Result<T, F>;
+    isOk(): this is OkImpl<T>;
+    isErr(): this is ErrImpl<never>;
+    expect(_msg: string): T;
+    expectErr(msg: string): never;
+    unwrap(): T;
+    unwrapOr(_fallback: T): T;
+    unwrapOrElse(_fallback: (val: never) => T): T;
+    unwrapErr(): never;
+}
+declare class ErrImpl<E> implements Result<never, E> {
+    private val;
+    constructor(val: E);
+    map<U>(_fn: (val: never) => U): Result<U, E>;
+    mapErr<F>(fn: (val: E) => F): Result<never, F>;
+    mapOr<U>(fallback: U, _fn: (val: never) => U): U;
+    mapOrElse<U>(fallback: () => U, _fn: (val: never) => U): U;
+    andThen<U>(_fn: (val: never) => Result<U, E>): Result<U, E>;
+    and<U>(_res: Result<U, E>): Result<U, E>;
+    or(res: Result<never, E>): Result<never, E>;
+    orElse<F>(fn: (val: E) => ErrImpl<F>): Result<never, F>;
+    isOk(): this is OkImpl<never>;
+    isErr(): this is ErrImpl<E>;
+    expect(msg: string): never;
+    expectErr(_msg: string): E;
+    unwrap(): never;
+    unwrapOr<T>(fallback: T): T;
+    unwrapOrElse<T>(fallback: (val: E) => T): T;
+    unwrapErr(): E;
+}
+
 type BuiltInType = PrimitiveType | FunctionType | ObjectType;
 type Type = BuiltInType | PhiType | TypeVar | PolyType | PropType | ObjectMethod$1;
 type PrimitiveType = {
@@ -177,6 +236,7 @@ declare const EnvironmentConfigSchema: z.ZodObject<{
     validateNoSetStateInRender: z.ZodDefault<z.ZodBoolean>;
     validateNoSetStateInPassiveEffects: z.ZodDefault<z.ZodBoolean>;
     validateNoJSXInTryStatements: z.ZodDefault<z.ZodBoolean>;
+    validateStaticComponents: z.ZodDefault<z.ZodBoolean>;
     validateMemoizedEffectDependencies: z.ZodDefault<z.ZodBoolean>;
     validateNoCapitalizedCalls: z.ZodDefault<z.ZodNullable<z.ZodArray<z.ZodString, "many">>>;
     validateBlocklistedImports: z.ZodDefault<z.ZodNullable<z.ZodArray<z.ZodString, "many">>>;
@@ -336,6 +396,7 @@ declare const EnvironmentConfigSchema: z.ZodObject<{
     validateNoSetStateInRender: boolean;
     validateNoSetStateInPassiveEffects: boolean;
     validateNoJSXInTryStatements: boolean;
+    validateStaticComponents: boolean;
     validateMemoizedEffectDependencies: boolean;
     validateNoCapitalizedCalls: string[] | null;
     validateBlocklistedImports: string[] | null;
@@ -419,6 +480,7 @@ declare const EnvironmentConfigSchema: z.ZodObject<{
     validateNoSetStateInRender?: boolean | undefined;
     validateNoSetStateInPassiveEffects?: boolean | undefined;
     validateNoJSXInTryStatements?: boolean | undefined;
+    validateStaticComponents?: boolean | undefined;
     validateMemoizedEffectDependencies?: boolean | undefined;
     validateNoCapitalizedCalls?: string[] | null | undefined;
     validateBlocklistedImports?: string[] | null | undefined;
@@ -487,6 +549,7 @@ declare class Environment {
     get nextIdentifierId(): IdentifierId;
     get nextBlockId(): BlockId;
     get nextScopeId(): ScopeId;
+    logErrors(errors: Result<void, CompilerError>): void;
     isContextIdentifier(node: t.Identifier): boolean;
     isHoistedIdentifier(node: t.Identifier): boolean;
     generateGloballyUniqueIdentifierName(name: string | null): ValidatedIdentifier;
@@ -1423,6 +1486,7 @@ declare class CompilerError extends Error {
     push(options: CompilerErrorDetailOptions): CompilerErrorDetail;
     pushErrorDetail(detail: CompilerErrorDetail): CompilerErrorDetail;
     hasErrors(): boolean;
+    asResult(): Result<void, CompilerError>;
     isCritical(): boolean;
 }
 

package/dist/index.js

@@ -110448,6 +110448,126 @@ var import_invariant4 = __toESM(require_invariant());
 // src/Entrypoint/Gating.ts
 var t = __toESM(require("@babel/types"));
 
+// src/Utils/Result.ts
+function Ok(val) {
+  return new OkImpl(val);
+}
+var OkImpl = class _OkImpl {
+  constructor(val) {
+    this.val = val;
+  }
+  map(fn) {
+    return new _OkImpl(fn(this.val));
+  }
+  mapErr(_fn) {
+    return this;
+  }
+  mapOr(_fallback, fn) {
+    return fn(this.val);
+  }
+  mapOrElse(_fallback, fn) {
+    return fn(this.val);
+  }
+  andThen(fn) {
+    return fn(this.val);
+  }
+  and(res) {
+    return res;
+  }
+  or(_res) {
+    return this;
+  }
+  orElse(_fn) {
+    return this;
+  }
+  isOk() {
+    return true;
+  }
+  isErr() {
+    return false;
+  }
+  expect(_msg) {
+    return this.val;
+  }
+  expectErr(msg) {
+    throw new Error(`${msg}: ${this.val}`);
+  }
+  unwrap() {
+    return this.val;
+  }
+  unwrapOr(_fallback) {
+    return this.val;
+  }
+  unwrapOrElse(_fallback) {
+    return this.val;
+  }
+  unwrapErr() {
+    if (this.val instanceof Error) {
+      throw this.val;
+    }
+    throw new Error(`Can't unwrap \`Ok\` to \`Err\`: ${this.val}`);
+  }
+};
+function Err(val) {
+  return new ErrImpl(val);
+}
+var ErrImpl = class _ErrImpl {
+  constructor(val) {
+    this.val = val;
+  }
+  map(_fn) {
+    return this;
+  }
+  mapErr(fn) {
+    return new _ErrImpl(fn(this.val));
+  }
+  mapOr(fallback, _fn) {
+    return fallback;
+  }
+  mapOrElse(fallback, _fn) {
+    return fallback();
+  }
+  andThen(_fn) {
+    return this;
+  }
+  and(_res) {
+    return this;
+  }
+  or(res) {
+    return res;
+  }
+  orElse(fn) {
+    return fn(this.val);
+  }
+  isOk() {
+    return false;
+  }
+  isErr() {
+    return true;
+  }
+  expect(msg) {
+    throw new Error(`${msg}: ${this.val}`);
+  }
+  expectErr(_msg) {
+    return this.val;
+  }
+  unwrap() {
+    if (this.val instanceof Error) {
+      throw this.val;
+    }
+    throw new Error(`Can't unwrap \`Err\` to \`Ok\`: ${this.val}`);
+  }
+  unwrapOr(fallback) {
+    return fallback;
+  }
+  unwrapOrElse(fallback) {
+    return fallback(this.val);
+  }
+  unwrapErr() {
+    return this.val;
+  }
+};
+
 // src/Utils/utils.ts
 function assertExhaustive(_, errorMsg) {
   throw new Error(errorMsg);
@@ -110682,6 +110802,9 @@ var CompilerError = class _CompilerError extends Error {
   hasErrors() {
     return this.details.length > 0;
   }
+  asResult() {
+    return this.hasErrors() ? Err(this) : Ok(void 0);
+  }
   /*
    * An error is critical if it means the compiler has entered into a broken state and cannot
    * continue safely. Other expected errors such as Todos mean that we can skip over that component
@@ -117244,126 +117367,6 @@ function validateMutableRange(mutableRange) {
 // src/HIR/BuildHIR.ts
 var import_invariant2 = __toESM(require_invariant());
 
-// src/Utils/Result.ts
-function Ok(val) {
-  return new OkImpl(val);
-}
-var OkImpl = class _OkImpl {
-  constructor(val) {
-    this.val = val;
-  }
-  map(fn) {
-    return new _OkImpl(fn(this.val));
-  }
-  mapErr(_fn) {
-    return this;
-  }
-  mapOr(_fallback, fn) {
-    return fn(this.val);
-  }
-  mapOrElse(_fallback, fn) {
-    return fn(this.val);
-  }
-  andThen(fn) {
-    return fn(this.val);
-  }
-  and(res) {
-    return res;
-  }
-  or(_res) {
-    return this;
-  }
-  orElse(_fn) {
-    return this;
-  }
-  isOk() {
-    return true;
-  }
-  isErr() {
-    return false;
-  }
-  expect(_msg) {
-    return this.val;
-  }
-  expectErr(msg) {
-    throw new Error(`${msg}: ${this.val}`);
-  }
-  unwrap() {
-    return this.val;
-  }
-  unwrapOr(_fallback) {
-    return this.val;
-  }
-  unwrapOrElse(_fallback) {
-    return this.val;
-  }
-  unwrapErr() {
-    if (this.val instanceof Error) {
-      throw this.val;
-    }
-    throw new Error(`Can't unwrap \`Ok\` to \`Err\`: ${this.val}`);
-  }
-};
-function Err(val) {
-  return new ErrImpl(val);
-}
-var ErrImpl = class _ErrImpl {
-  constructor(val) {
-    this.val = val;
-  }
-  map(_fn) {
-    return this;
-  }
-  mapErr(fn) {
-    return new _ErrImpl(fn(this.val));
-  }
-  mapOr(fallback, _fn) {
-    return fallback;
-  }
-  mapOrElse(fallback, _fn) {
-    return fallback();
-  }
-  andThen(_fn) {
-    return this;
-  }
-  and(_res) {
-    return this;
-  }
-  or(res) {
-    return res;
-  }
-  orElse(fn) {
-    return fn(this.val);
-  }
-  isOk() {
-    return false;
-  }
-  isErr() {
-    return true;
-  }
-  expect(msg) {
-    throw new Error(`${msg}: ${this.val}`);
-  }
-  expectErr(_msg) {
-    return this.val;
-  }
-  unwrap() {
-    if (this.val instanceof Error) {
-      throw this.val;
-    }
-    throw new Error(`Can't unwrap \`Err\` to \`Ok\`: ${this.val}`);
-  }
-  unwrapOr(fallback) {
-    return fallback;
-  }
-  unwrapOrElse(fallback) {
-    return fallback(this.val);
-  }
-  unwrapErr() {
-    return this.val;
-  }
-};
-
 // src/HIR/HIRBuilder.ts
 function newBlock(id, kind) {
   return { id, kind, instructions: [] };
@@ -123583,6 +123586,10 @@ var EnvironmentConfigSchema = z.object({
    * instead.
    */
   validateNoJSXInTryStatements: z.boolean().default(false),
+  /**
+   * Validates against dynamically creating components during render.
+   */
+  validateStaticComponents: z.boolean().default(false),
   /**
    * Validates that the dependencies of all effect hooks are memoized. This helps ensure
    * that Forget does not introduce infinite renders caused by a dependency changing,
@@ -124073,6 +124080,18 @@ var Environment = class {
   get nextScopeId() {
     return makeScopeId(__privateWrapper(this, _nextScope)._++);
   }
+  logErrors(errors) {
+    if (errors.isOk() || this.logger == null) {
+      return;
+    }
+    for (const error of errors.unwrapErr().details) {
+      this.logger.logEvent(this.filename, {
+        kind: "CompileError",
+        detail: error,
+        fnLoc: null
+      });
+    }
+  }
   isContextIdentifier(node) {
     return __privateGet(this, _contextIdentifiers).has(node);
   }
@@ -129176,7 +129195,7 @@ function codegenFunction(fn, {
   }
   const compiled = compileResult.unwrap();
   const hookGuard = fn.env.config.enableEmitHookGuards;
-  if (hookGuard != null) {
+  if (hookGuard != null && fn.env.isInferredMemoEnabled) {
     compiled.body = t4.blockStatement([
       createHookGuard(
         hookGuard,
@@ -129265,7 +129284,7 @@ function codegenFunction(fn, {
     compiled.body.body.unshift(...preface);
   }
   const emitInstrumentForget = fn.env.config.enableEmitInstrumentForget;
-  if (emitInstrumentForget != null && fn.id != null) {
+  if (emitInstrumentForget != null && fn.id != null && fn.env.isInferredMemoEnabled) {
     let gating;
     if (emitInstrumentForget.gating != null && emitInstrumentForget.globalGating != null) {
       gating = t4.logicalExpression(
@@ -129500,7 +129519,7 @@ function codegenBlockNoReset(cx, block) {
   return t4.blockStatement(statements);
 }
 function wrapCacheDep(cx, value) {
-  if (cx.env.config.enableEmitFreeze != null) {
+  if (cx.env.config.enableEmitFreeze != null && cx.env.isInferredMemoEnabled) {
     return t4.conditionalExpression(
       t4.identifier("__DEV__"),
       t4.callExpression(
@@ -130367,13 +130386,13 @@ function createHookGuard(guard, stmts, before, after) {
     t4.blockStatement([createHookGuardImpl(after)])
   );
 }
-function createCallExpression(config, callee, args, loc, isHook2) {
+function createCallExpression(env, callee, args, loc, isHook2) {
   const callExpr = t4.callExpression(callee, args);
   if (loc != null && loc != GeneratedSource) {
     callExpr.loc = loc;
   }
-  const hookGuard = config.enableEmitHookGuards;
-  if (hookGuard != null && isHook2) {
+  const hookGuard = env.config.enableEmitHookGuards;
+  if (hookGuard != null && isHook2 && env.isInferredMemoEnabled) {
     const iife = t4.functionExpression(
       null,
       [],
@@ -130491,7 +130510,7 @@ function codegenInstructionValue(cx, instrValue) {
       const callee = codegenPlaceToExpression(cx, instrValue.callee);
       const args = instrValue.args.map((arg) => codegenArgument(cx, arg));
       value = createCallExpression(
-        cx.env.config,
+        cx.env,
         callee,
         args,
         instrValue.loc,
@@ -130574,7 +130593,7 @@ function codegenInstructionValue(cx, instrValue) {
       );
       const args = instrValue.args.map((arg) => codegenArgument(cx, arg));
       value = createCallExpression(
-        cx.env.config,
+        cx.env,
         memberExpr,
         args,
         instrValue.loc,
@@ -138033,9 +138052,7 @@ function validateHooksUsage(fn) {
   for (const [, error] of errorsByPlace) {
     errors.push(error);
   }
-  if (errors.hasErrors()) {
-    throw errors;
-  }
+  return errors.asResult();
 }
 function visitFunctionExpression(errors, fn) {
   for (const [, block] of fn.body.blocks) {
@@ -138072,9 +138089,7 @@ function visitFunctionExpression(errors, fn) {
 function validateMemoizedEffectDependencies(fn) {
   const errors = new CompilerError();
   visitReactiveFunction(fn, new Visitor10(), errors);
-  if (errors.hasErrors()) {
-    throw errors;
-  }
+  return errors.asResult();
 }
 var Visitor10 = class extends ReactiveFunctionVisitor {
   constructor() {
@@ -138136,6 +138151,7 @@ function validateNoCapitalizedCalls(fn) {
   const isAllowed = (name) => {
     return ALLOW_LIST.has(name) || hookPattern != null && hookPattern.test(name);
   };
+  const errors = new CompilerError();
   const capitalLoadGlobals = /* @__PURE__ */ new Map();
   const capitalizedProperties = /* @__PURE__ */ new Map();
   const reason = "Capitalized functions are reserved for components, which must be invoked with JSX. If this is a component, render it with JSX. Otherwise, ensure that it has no hook calls and rename it to begin with a lowercase letter. Alternatively, if you know for a fact that this function is not a component, you can allowlist it via the compiler config";
@@ -138172,7 +138188,8 @@ function validateNoCapitalizedCalls(fn) {
           const propertyIdentifier = value.property.identifier.id;
           const propertyName = capitalizedProperties.get(propertyIdentifier);
           if (propertyName != null) {
-            CompilerError.throwInvalidReact({
+            errors.push({
+              severity: "InvalidReact" /* InvalidReact */,
               reason,
               description: `${propertyName} may be a component.`,
               loc: value.loc,
@@ -138184,6 +138201,7 @@ function validateNoCapitalizedCalls(fn) {
       }
     }
   }
+  return errors.asResult();
 }
 
 // src/Validation/ValidateNoRefAccesInRender.ts
@@ -138225,7 +138243,7 @@ var Env = class extends Map {
 _changed = new WeakMap();
 function validateNoRefAccessInRender(fn) {
   const env = new Env();
-  validateNoRefAccessInRenderImpl(fn, env).unwrap();
+  return validateNoRefAccessInRenderImpl(fn, env).map((_) => void 0);
 }
 function refTypeOfType(place) {
   if (isRefValueType(place.identifier)) {
@@ -138687,7 +138705,7 @@ function validateNoDirectRefValueAccess(errors, operand, env) {
 // src/Validation/ValidateNoSetStateInRender.ts
 function validateNoSetStateInRender(fn) {
   const unconditionalSetStateFunctions = /* @__PURE__ */ new Set();
-  validateNoSetStateInRenderImpl(fn, unconditionalSetStateFunctions).unwrap();
+  return validateNoSetStateInRenderImpl(fn, unconditionalSetStateFunctions);
 }
 function validateNoSetStateInRenderImpl(fn, unconditionalSetStateFunctions) {
   const unconditionalBlocks = computeUnconditionalBlocks(fn);
@@ -138772,11 +138790,7 @@ function validateNoSetStateInRenderImpl(fn, unconditionalSetStateFunctions) {
       }
     }
   }
-  if (errors.hasErrors()) {
-    return Err(errors);
-  } else {
-    return Ok(void 0);
-  }
+  return errors.asResult();
 }
 
 // src/Validation/ValidatePreservedManualMemoization.ts
@@ -138786,9 +138800,7 @@ function validatePreservedManualMemoization(fn) {
     manualMemoState: null
   };
   visitReactiveFunction(fn, new Visitor11(), state);
-  if (state.errors.hasErrors()) {
-    throw state.errors;
-  }
+  return state.errors.asResult();
 }
 var DEBUG4 = false;
 function prettyPrintScopeDependency(val) {
@@ -139108,6 +139120,7 @@ function isUnmemoized2(operand, scopes) {
 
 // src/Validation/ValidateUseMemo.ts
 function validateUseMemo(fn) {
+  const errors = new CompilerError();
   const useMemos = /* @__PURE__ */ new Set();
   const react = /* @__PURE__ */ new Set();
   const functions = /* @__PURE__ */ new Map();
@@ -139150,7 +139163,8 @@ function validateUseMemo(fn) {
             continue;
           }
           if (body.loweredFunc.func.params.length > 0) {
-            CompilerError.throwInvalidReact({
+            errors.push({
+              severity: "InvalidReact" /* InvalidReact */,
               reason: "useMemo callbacks may not accept any arguments",
               description: null,
               loc: body.loc,
@@ -139158,7 +139172,8 @@ function validateUseMemo(fn) {
             });
           }
           if (body.loweredFunc.func.async || body.loweredFunc.func.generator) {
-            CompilerError.throwInvalidReact({
+            errors.push({
+              severity: "InvalidReact" /* InvalidReact */,
               reason: "useMemo callbacks may not be async or generator functions",
               description: null,
               loc: body.loc,
@@ -139170,6 +139185,7 @@ function validateUseMemo(fn) {
       }
     }
   }
+  return errors.asResult();
 }
 
 // src/Validation/ValidateLocalsNotReassignedAfterRender.ts
@@ -139676,9 +139692,7 @@ function validateNoSetStateInPassiveEffects(fn) {
       }
     }
   }
-  if (errors.hasErrors()) {
-    throw errors;
-  }
+  return errors.asResult();
 }
 function getSetStateCall(fn, setStateFunctions) {
   for (const [, block] of fn.body.blocks) {
@@ -139744,9 +139758,7 @@ function validateNoJSXInTryStatement(fn) {
       activeTryBlocks.push(block.terminal.handler);
     }
   }
-  if (errors.hasErrors()) {
-    throw errors;
-  }
+  return errors.asResult();
 }
 
 // src/HIR/CollectHoistablePropertyLoads.ts
@@ -141951,7 +141963,7 @@ function rewriteInstructions(rewriteInstrs, instructions) {
   return instructions;
 }
 
-// src/Validation/ValiateNoImpureFunctionsInRender.ts
+// src/Validation/ValidateNoImpureFunctionsInRender.ts
 function validateNoImpureFunctionsInRender(fn) {
   const errors = new CompilerError();
   for (const [, block] of fn.body.blocks) {
@@ -141975,9 +141987,75 @@ function validateNoImpureFunctionsInRender(fn) {
       }
     }
   }
-  if (errors.hasErrors()) {
-    throw errors;
+  return errors.asResult();
+}
+
+// src/Validation/ValidateStaticComponents.ts
+function validateStaticComponents(fn) {
+  const error = new CompilerError();
+  const knownDynamicComponents = /* @__PURE__ */ new Map();
+  for (const block of fn.body.blocks.values()) {
+    phis: for (const phi of block.phis) {
+      for (const operand of phi.operands.values()) {
+        const loc = knownDynamicComponents.get(operand.identifier.id);
+        if (loc != null) {
+          knownDynamicComponents.set(phi.place.identifier.id, loc);
+          continue phis;
+        }
+      }
+    }
+    for (const instr of block.instructions) {
+      const { lvalue, value } = instr;
+      switch (value.kind) {
+        case "FunctionExpression":
+        case "NewExpression":
+        case "MethodCall":
+        case "CallExpression": {
+          knownDynamicComponents.set(lvalue.identifier.id, value.loc);
+          break;
+        }
+        case "LoadLocal": {
+          const loc = knownDynamicComponents.get(value.place.identifier.id);
+          if (loc != null) {
+            knownDynamicComponents.set(lvalue.identifier.id, loc);
+          }
+          break;
+        }
+        case "StoreLocal": {
+          const loc = knownDynamicComponents.get(value.value.identifier.id);
+          if (loc != null) {
+            knownDynamicComponents.set(lvalue.identifier.id, loc);
+            knownDynamicComponents.set(value.lvalue.place.identifier.id, loc);
+          }
+          break;
+        }
+        case "JsxExpression": {
+          if (value.tag.kind === "Identifier") {
+            const location = knownDynamicComponents.get(
+              value.tag.identifier.id
+            );
+            if (location != null) {
+              error.push({
+                reason: `Components created during render will reset their state each time they are created. Declare components outside of render. `,
+                severity: "InvalidReact" /* InvalidReact */,
+                loc: value.tag.loc,
+                description: null,
+                suggestions: null
+              });
+              error.push({
+                reason: `The component may be created during render`,
+                severity: "InvalidReact" /* InvalidReact */,
+                loc: location,
+                description: null,
+                suggestions: null
+              });
+            }
+          }
+        }
+      }
+    }
   }
+  return error.asResult();
 }
 
 // src/Entrypoint/Pipeline.ts
@@ -142012,7 +142090,7 @@ function runWithEnvironment(func, env) {
   pruneMaybeThrows(hir);
   log2({ kind: "hir", name: "PruneMaybeThrows", value: hir });
   validateContextVariableLValues(hir);
-  validateUseMemo(hir);
+  validateUseMemo(hir).unwrap();
   if (env.isInferredMemoEnabled && !env.config.enablePreserveExistingManualUseMemo && !env.config.disableMemoizationForDebugging && !env.config.enableChangeDetectionForDebugging) {
     dropManualMemoization(hir);
     log2({ kind: "hir", name: "DropManualMemoization", value: hir });
@@ -142038,10 +142116,10 @@ function runWithEnvironment(func, env) {
   log2({ kind: "hir", name: "InferTypes", value: hir });
   if (env.isInferredMemoEnabled) {
     if (env.config.validateHooksUsage) {
-      validateHooksUsage(hir);
+      validateHooksUsage(hir).unwrap();
     }
     if (env.config.validateNoCapitalizedCalls) {
-      validateNoCapitalizedCalls(hir);
+      validateNoCapitalizedCalls(hir).unwrap();
     }
   }
   if (env.config.enableFire) {
@@ -142078,19 +142156,19 @@ function runWithEnvironment(func, env) {
       assertValidMutableRanges(hir);
     }
     if (env.config.validateRefAccessDuringRender) {
-      validateNoRefAccessInRender(hir);
+      validateNoRefAccessInRender(hir).unwrap();
     }
     if (env.config.validateNoSetStateInRender) {
-      validateNoSetStateInRender(hir);
+      validateNoSetStateInRender(hir).unwrap();
     }
     if (env.config.validateNoSetStateInPassiveEffects) {
-      validateNoSetStateInPassiveEffects(hir);
+      env.logErrors(validateNoSetStateInPassiveEffects(hir));
     }
     if (env.config.validateNoJSXInTryStatements) {
-      validateNoJSXInTryStatement(hir);
+      env.logErrors(validateNoJSXInTryStatement(hir));
     }
     if (env.config.validateNoImpureFunctionsInRender) {
-      validateNoImpureFunctionsInRender(hir);
+      validateNoImpureFunctionsInRender(hir).unwrap();
     }
   }
   inferReactivePlaces(hir);
@@ -142108,6 +142186,9 @@ function runWithEnvironment(func, env) {
     value: hir
   });
   if (env.isInferredMemoEnabled) {
+    if (env.config.validateStaticComponents) {
+      env.logErrors(validateStaticComponents(hir));
+    }
     inferReactiveScopeVariables(hir);
     log2({ kind: "hir", name: "InferReactiveScopeVariables", value: hir });
   }
@@ -142288,10 +142369,10 @@ function runWithEnvironment(func, env) {
     value: reactiveFunction
   });
   if (env.config.validateMemoizedEffectDependencies) {
-    validateMemoizedEffectDependencies(reactiveFunction);
+    validateMemoizedEffectDependencies(reactiveFunction).unwrap();
   }
   if (env.config.enablePreserveExistingMemoizationGuarantees || env.config.validatePreserveExistingMemoizationGuarantees) {
-    validatePreservedManualMemoization(reactiveFunction);
+    validatePreservedManualMemoization(reactiveFunction).unwrap();
   }
   const ast = codegenFunction(reactiveFunction, {
     uniqueIdentifiers,
@@ -142732,6 +142813,9 @@ function compileProgram(program, pass) {
             pass.code
           )
         };
+        if (!compileResult.compiledFn.hasFireRewrite && !compileResult.compiledFn.hasLoweredContextAccess) {
+          return null;
+        }
       } catch (err) {
         if (err instanceof CompilerError) {
           retryErrors.push({ fn, error: err });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "babel-plugin-react-compiler",
-  "version": "0.0.0-experimental-afa1d5a-20250319",
+  "version": "0.0.0-experimental-3452ff1-20250321",
   "description": "Babel plugin for React Compiler.",
   "main": "dist/index.js",
   "license": "MIT",