babel-plugin-react-compiler 0.0.0-experimental-d664a4c-20250313 → 0.0.0-experimental-3229e95-20250317

package/dist/index.d.ts

@@ -77,6 +77,7 @@ declare const ExternalFunctionSchema: z.ZodObject<{
     importSpecifierName: string;
 }>;
 type ExternalFunction = z.infer<typeof ExternalFunctionSchema>;
+type CompilerMode = 'all_features' | 'no_inferred_memo';
 declare const HookSchema: z.ZodObject<{
     effectKind: z.ZodNativeEnum<typeof Effect>;
     valueKind: z.ZodNativeEnum<typeof ValueKind>;
@@ -274,7 +275,6 @@ declare const EnvironmentConfigSchema: z.ZodObject<{
     throwUnknownException__testonly: z.ZodDefault<z.ZodBoolean>;
     enableTreatFunctionDepsAsConditional: z.ZodDefault<z.ZodBoolean>;
     disableMemoizationForDebugging: z.ZodDefault<z.ZodBoolean>;
-    enableMinimalTransformsForRetry: z.ZodDefault<z.ZodBoolean>;
     enableChangeDetectionForDebugging: z.ZodDefault<z.ZodNullable<z.ZodObject<{
         source: z.ZodString;
         importSpecifierName: z.ZodString;
@@ -370,7 +370,6 @@ declare const EnvironmentConfigSchema: z.ZodObject<{
     throwUnknownException__testonly: boolean;
     enableTreatFunctionDepsAsConditional: boolean;
     disableMemoizationForDebugging: boolean;
-    enableMinimalTransformsForRetry: boolean;
     enableChangeDetectionForDebugging: {
         source: string;
         importSpecifierName: string;
@@ -454,7 +453,6 @@ declare const EnvironmentConfigSchema: z.ZodObject<{
     throwUnknownException__testonly?: boolean | undefined;
     enableTreatFunctionDepsAsConditional?: boolean | undefined;
     disableMemoizationForDebugging?: boolean | undefined;
-    enableMinimalTransformsForRetry?: boolean | undefined;
     enableChangeDetectionForDebugging?: {
         source: string;
         importSpecifierName: string;
@@ -480,10 +478,12 @@ declare class Environment {
     code: string | null;
     config: EnvironmentConfig;
     fnType: ReactFunctionType;
+    compilerMode: CompilerMode;
     useMemoCacheIdentifier: string;
     hasLoweredContextAccess: boolean;
     hasFireRewrite: boolean;
-    constructor(scope: Scope, fnType: ReactFunctionType, config: EnvironmentConfig, contextIdentifiers: Set<t.Identifier>, logger: Logger | null, filename: string | null, code: string | null, useMemoCacheIdentifier: string);
+    constructor(scope: Scope, fnType: ReactFunctionType, compilerMode: CompilerMode, config: EnvironmentConfig, contextIdentifiers: Set<t.Identifier>, logger: Logger | null, filename: string | null, code: string | null, useMemoCacheIdentifier: string);
+    get isInferredMemoEnabled(): boolean;
     get nextIdentifierId(): IdentifierId;
     get nextBlockId(): BlockId;
     get nextScopeId(): ScopeId;
@@ -496,6 +496,7 @@ declare class Environment {
         type: ReactFunctionType | null;
     }>;
     getGlobalDeclaration(binding: NonLocalBinding, loc: SourceLocation): Global | null;
+    static knownReactModules: ReadonlyArray<string>;
     getFallthroughPropertyType(receiver: Type, _property: Type): BuiltInType | PolyType | null;
     getPropertyType(receiver: Type, property: string | number): BuiltInType | PolyType | null;
     getFunctionSignature(type: FunctionType): FunctionSignature | null;
@@ -1462,7 +1463,7 @@ type CompilerPipelineValue = {
     name: string;
     value: string;
 };
-declare function compileFn(func: NodePath<t.FunctionDeclaration | t.ArrowFunctionExpression | t.FunctionExpression>, config: EnvironmentConfig, fnType: ReactFunctionType, useMemoCacheIdentifier: string, logger: Logger | null, filename: string | null, code: string | null): CodegenFunction;
+declare function compileFn(func: NodePath<t.FunctionDeclaration | t.ArrowFunctionExpression | t.FunctionExpression>, config: EnvironmentConfig, fnType: ReactFunctionType, mode: CompilerMode, useMemoCacheIdentifier: string, logger: Logger | null, filename: string | null, code: string | null): CodegenFunction;
 
 declare const PanicThresholdOptionsSchema: z.ZodEnum<["all_errors", "critical_errors", "none"]>;
 type PanicThresholdOptions = z.infer<typeof PanicThresholdOptionsSchema>;
@@ -1545,7 +1546,14 @@ declare const OPT_IN_DIRECTIVES: Set<string>;
 declare const OPT_OUT_DIRECTIVES: Set<string>;
 declare function findDirectiveEnablingMemoization(directives: Array<t.Directive>): Array<t.Directive>;
 declare function findDirectiveDisablingMemoization(directives: Array<t.Directive>): Array<t.Directive>;
-declare function compileProgram(program: NodePath$1<t.Program>, pass: CompilerPass): void;
+type BabelFn = NodePath$1<t.FunctionDeclaration> | NodePath$1<t.FunctionExpression> | NodePath$1<t.ArrowFunctionExpression>;
+type CompileProgramResult = {
+    retryErrors: Array<{
+        fn: BabelFn;
+        error: CompilerError;
+    }>;
+};
+declare function compileProgram(program: NodePath$1<t.Program>, pass: CompilerPass): CompileProgramResult | null;
 
 declare function runBabelPluginReactCompiler(text: string, file: string, language: 'flow' | 'typescript', options: Partial<PluginOptions> | null, includeAst?: boolean): BabelCore.BabelFileResult;
 

package/dist/index.js

@@ -12103,9 +12103,9 @@ var require_inferer_reference = __commonJS({
       }
     }
     function getConditionalAnnotation(binding, path, name) {
-      const ifStatement2 = getParentConditionalPath(binding, path, name);
-      if (!ifStatement2) return;
-      const test = ifStatement2.get("test");
+      const ifStatement3 = getParentConditionalPath(binding, path, name);
+      if (!ifStatement3) return;
+      const test = ifStatement3.get("test");
       const paths = [test];
       const types = [];
       for (let i = 0; i < paths.length; i++) {
@@ -12123,10 +12123,10 @@ var require_inferer_reference = __commonJS({
       if (types.length) {
         return {
           typeAnnotation: (0, _util.createUnionType)(types),
-          ifStatement: ifStatement2
+          ifStatement: ifStatement3
         };
       }
-      return getConditionalAnnotation(binding, ifStatement2, name);
+      return getConditionalAnnotation(binding, ifStatement3, name);
     }
   }
 });
@@ -13265,7 +13265,7 @@ var require_modification = __commonJS({
       arrowFunctionExpression: arrowFunctionExpression2,
       assertExpression,
       assignmentExpression: assignmentExpression2,
-      blockStatement: blockStatement2,
+      blockStatement: blockStatement3,
       callExpression: callExpression3,
       cloneNode: cloneNode2,
       expressionStatement: expressionStatement2,
@@ -13295,7 +13295,7 @@ var require_modification = __commonJS({
       } else if (this.isStatementOrBlock()) {
         const node = this.node;
         const shouldInsertCurrentNode = node && (!this.isExpressionStatement() || node.expression != null);
-        this.replaceWith(blockStatement2(shouldInsertCurrentNode ? [node] : []));
+        this.replaceWith(blockStatement3(shouldInsertCurrentNode ? [node] : []));
         return this.unshiftContainer("body", nodes);
       } else {
         throw new Error("We don't know what to do with this node type. We were previously a Statement but we can't fit in here?");
@@ -13396,7 +13396,7 @@ var require_modification = __commonJS({
       } else if (this.isStatementOrBlock()) {
         const node = this.node;
         const shouldInsertCurrentNode = node && (!this.isExpressionStatement() || node.expression != null);
-        this.replaceWith(blockStatement2(shouldInsertCurrentNode ? [node] : []));
+        this.replaceWith(blockStatement3(shouldInsertCurrentNode ? [node] : []));
         return this.pushContainer("body", nodes);
       } else {
         throw new Error("We don't know what to do with this node type. We were previously a Statement but we can't fit in here?");
@@ -27502,7 +27502,7 @@ var require_replacement = __commonJS({
       arrowFunctionExpression: arrowFunctionExpression2,
       assignmentExpression: assignmentExpression2,
       awaitExpression: awaitExpression2,
-      blockStatement: blockStatement2,
+      blockStatement: blockStatement3,
       buildUndefinedNode,
       callExpression: callExpression3,
       cloneNode: cloneNode2,
@@ -27522,7 +27522,7 @@ var require_replacement = __commonJS({
       isStatement: isStatement2,
       isVariableDeclaration: isVariableDeclaration2,
       removeComments,
-      returnStatement: returnStatement2,
+      returnStatement: returnStatement3,
       sequenceExpression: sequenceExpression2,
       validate: validate2,
       yieldExpression
@@ -27637,7 +27637,7 @@ var require_replacement = __commonJS({
       const functionParent = this.getFunctionParent();
       const isParentAsync = functionParent == null ? void 0 : functionParent.node.async;
       const isParentGenerator = functionParent == null ? void 0 : functionParent.node.generator;
-      const container = arrowFunctionExpression2([], blockStatement2(nodes));
+      const container = arrowFunctionExpression2([], blockStatement3(nodes));
       this.replaceWith(callExpression3(container, []));
       const callee = this.get("callee");
       callee.get("body").scope.hoistVariables((id) => this.scope.push({
@@ -27651,14 +27651,14 @@ var require_replacement = __commonJS({
           let uid = loop.getData("expressionReplacementReturnUid");
           if (!uid) {
             uid = callee.scope.generateDeclaredUidIdentifier("ret");
-            callee.get("body").pushContainer("body", returnStatement2(cloneNode2(uid)));
+            callee.get("body").pushContainer("body", returnStatement3(cloneNode2(uid)));
             loop.setData("expressionReplacementReturnUid", uid);
           } else {
             uid = identifier4(uid.name);
           }
           path.get("expression").replaceWith(assignmentExpression2("=", cloneNode2(uid), path.node.expression));
         } else {
-          path.replaceWith(returnStatement2(path.node.expression));
+          path.replaceWith(returnStatement3(path.node.expression));
         }
       }
       callee.arrowFunctionToExpression();
@@ -28416,7 +28416,7 @@ var require_populate = __commonJS({
     exports2.default = populatePlaceholders;
     var _t = require("@babel/types");
     var {
-      blockStatement: blockStatement2,
+      blockStatement: blockStatement3,
       cloneNode: cloneNode2,
       emptyStatement: emptyStatement2,
       expressionStatement: expressionStatement2,
@@ -28479,7 +28479,7 @@ var require_populate = __commonJS({
           if (!replacement) {
             replacement = emptyStatement2();
           } else if (Array.isArray(replacement)) {
-            replacement = blockStatement2(replacement);
+            replacement = blockStatement3(replacement);
           } else if (typeof replacement === "string") {
             replacement = expressionStatement2(identifier4(replacement));
           } else if (!isStatement2(replacement)) {
@@ -28762,7 +28762,7 @@ var require_conversion = __commonJS({
       arrowFunctionExpression: arrowFunctionExpression2,
       assignmentExpression: assignmentExpression2,
       binaryExpression: binaryExpression2,
-      blockStatement: blockStatement2,
+      blockStatement: blockStatement3,
       callExpression: callExpression3,
       conditionalExpression: conditionalExpression3,
       expressionStatement: expressionStatement2,
@@ -28775,10 +28775,10 @@ var require_conversion = __commonJS({
       metaProperty: metaProperty2,
       numericLiteral: numericLiteral2,
       objectExpression: objectExpression2,
-      restElement: restElement2,
-      returnStatement: returnStatement2,
+      restElement: restElement3,
+      returnStatement: returnStatement3,
       sequenceExpression: sequenceExpression2,
-      spreadElement: spreadElement2,
+      spreadElement: spreadElement3,
       stringLiteral: stringLiteral3,
       super: _super,
       thisExpression,
@@ -28834,13 +28834,13 @@ var require_conversion = __commonJS({
         stringPath += ".body.0";
         if (this.isFunction()) {
           key2 = "argument";
-          statements.push(returnStatement2(body.node));
+          statements.push(returnStatement3(body.node));
         } else {
           key2 = "expression";
           statements.push(expressionStatement2(body.node));
         }
       }
-      this.node.body = blockStatement2(statements);
+      this.node.body = blockStatement3(statements);
       const parentPath = this.get(stringPath);
       _context3.setup.call(body, parentPath, listKey ? parentPath.node[listKey] : parentPath.node, listKey, key2);
       return this.node;
@@ -29110,7 +29110,7 @@ var require_conversion = __commonJS({
     function getSuperBinding(thisEnvFn) {
       return getBinding(thisEnvFn, "supercall", () => {
         const argsBinding = thisEnvFn.scope.generateUidIdentifier("args");
-        return arrowFunctionExpression2([restElement2(argsBinding)], callExpression3(_super(), [spreadElement2(identifier4(argsBinding.name))]));
+        return arrowFunctionExpression2([restElement3(argsBinding)], callExpression3(_super(), [spreadElement3(identifier4(argsBinding.name))]));
       });
     }
     function getSuperPropBinding(thisEnvFn, isAssignment, propName) {
@@ -47261,7 +47261,7 @@ var require_populate2 = __commonJS({
     exports2.default = populatePlaceholders;
     var _t = require("@babel/types");
     var {
-      blockStatement: blockStatement2,
+      blockStatement: blockStatement3,
       cloneNode: cloneNode2,
       emptyStatement: emptyStatement2,
       expressionStatement: expressionStatement2,
@@ -47324,7 +47324,7 @@ var require_populate2 = __commonJS({
           if (!replacement) {
             replacement = emptyStatement2();
           } else if (Array.isArray(replacement)) {
-            replacement = blockStatement2(replacement);
+            replacement = blockStatement3(replacement);
           } else if (typeof replacement === "string") {
             replacement = expressionStatement2(identifier4(replacement));
           } else if (!isStatement2(replacement)) {
@@ -57983,9 +57983,9 @@ var require_inferer_reference2 = __commonJS({
       }
     }
     function getConditionalAnnotation(binding, path, name) {
-      const ifStatement2 = getParentConditionalPath(binding, path, name);
-      if (!ifStatement2) return;
-      const test = ifStatement2.get("test");
+      const ifStatement3 = getParentConditionalPath(binding, path, name);
+      if (!ifStatement3) return;
+      const test = ifStatement3.get("test");
       const paths = [test];
       const types = [];
       for (let i = 0; i < paths.length; i++) {
@@ -58003,10 +58003,10 @@ var require_inferer_reference2 = __commonJS({
       if (types.length) {
         return {
           typeAnnotation: t5.createUnionTypeAnnotation(types),
-          ifStatement: ifStatement2
+          ifStatement: ifStatement3
         };
       }
-      return getConditionalAnnotation(ifStatement2, name);
+      return getConditionalAnnotation(ifStatement3, name);
     }
   }
 });
@@ -89611,7 +89611,7 @@ var require_populate3 = __commonJS({
     exports2.default = populatePlaceholders;
     var _t = require("@babel/types");
     var {
-      blockStatement: blockStatement2,
+      blockStatement: blockStatement3,
       cloneNode: cloneNode2,
       emptyStatement: emptyStatement2,
       expressionStatement: expressionStatement2,
@@ -89674,7 +89674,7 @@ var require_populate3 = __commonJS({
           if (!replacement) {
             replacement = emptyStatement2();
           } else if (Array.isArray(replacement)) {
-            replacement = blockStatement2(replacement);
+            replacement = blockStatement3(replacement);
           } else if (typeof replacement === "string") {
             replacement = expressionStatement2(identifier4(replacement));
           } else if (!isStatement2(replacement)) {
@@ -110447,54 +110447,6 @@ var import_invariant4 = __toESM(require_invariant());
 
 // src/Entrypoint/Gating.ts
 var t = __toESM(require("@babel/types"));
-function insertGatedFunctionDeclaration(fnPath, compiled, gating) {
-  const gatingExpression = t.conditionalExpression(
-    t.callExpression(t.identifier(gating.importSpecifierName), []),
-    buildFunctionExpression(compiled),
-    buildFunctionExpression(fnPath.node)
-  );
-  if (fnPath.parentPath.node.type !== "ExportDefaultDeclaration" && fnPath.node.type === "FunctionDeclaration" && fnPath.node.id != null) {
-    fnPath.replaceWith(
-      t.variableDeclaration("const", [
-        t.variableDeclarator(fnPath.node.id, gatingExpression)
-      ])
-    );
-  } else if (fnPath.parentPath.node.type === "ExportDefaultDeclaration" && fnPath.node.type !== "ArrowFunctionExpression" && fnPath.node.id != null) {
-    fnPath.insertAfter(
-      t.exportDefaultDeclaration(t.identifier(fnPath.node.id.name))
-    );
-    fnPath.parentPath.replaceWith(
-      t.variableDeclaration("const", [
-        t.variableDeclarator(
-          t.identifier(fnPath.node.id.name),
-          gatingExpression
-        )
-      ])
-    );
-  } else {
-    fnPath.replaceWith(gatingExpression);
-  }
-}
-function buildFunctionExpression(node) {
-  var _a, _b;
-  if (node.type === "ArrowFunctionExpression" || node.type === "FunctionExpression") {
-    return node;
-  } else {
-    const fn = {
-      type: "FunctionExpression",
-      async: node.async,
-      generator: node.generator,
-      loc: (_a = node.loc) != null ? _a : null,
-      id: (_b = node.id) != null ? _b : null,
-      params: node.params,
-      body: node.body
-    };
-    return fn;
-  }
-}
-
-// src/Entrypoint/Imports.ts
-var t3 = __toESM(require("@babel/types"));
 
 // src/Utils/utils.ts
 function assertExhaustive(_, errorMsg) {
@@ -110753,6 +110705,135 @@ var CompilerError = class _CompilerError extends Error {
   }
 };
 
+// src/Entrypoint/Gating.ts
+function insertAdditionalFunctionDeclaration(fnPath, compiled, gating) {
+  var _a, _b;
+  const originalFnName = fnPath.node.id;
+  const originalFnParams = fnPath.node.params;
+  const compiledParams = fnPath.node.params;
+  CompilerError.invariant(originalFnName != null && compiled.id != null, {
+    reason: "Expected function declarations that are referenced elsewhere to have a named identifier",
+    loc: (_a = fnPath.node.loc) != null ? _a : null
+  });
+  CompilerError.invariant(originalFnParams.length === compiledParams.length, {
+    reason: "Expected React Compiler optimized function declarations to have the same number of parameters as source",
+    loc: (_b = fnPath.node.loc) != null ? _b : null
+  });
+  const gatingCondition = fnPath.scope.generateUidIdentifier(
+    `${gating.importSpecifierName}_result`
+  );
+  const unoptimizedFnName = fnPath.scope.generateUidIdentifier(
+    `${originalFnName.name}_unoptimized`
+  );
+  const optimizedFnName = fnPath.scope.generateUidIdentifier(
+    `${originalFnName.name}_optimized`
+  );
+  compiled.id.name = optimizedFnName.name;
+  fnPath.get("id").replaceInline(unoptimizedFnName);
+  const newParams = [];
+  const genNewArgs = [];
+  for (let i = 0; i < originalFnParams.length; i++) {
+    const argName = `arg${i}`;
+    if (originalFnParams[i].type === "RestElement") {
+      newParams.push(t.restElement(t.identifier(argName)));
+      genNewArgs.push(() => t.spreadElement(t.identifier(argName)));
+    } else {
+      newParams.push(t.identifier(argName));
+      genNewArgs.push(() => t.identifier(argName));
+    }
+  }
+  fnPath.insertAfter(
+    t.functionDeclaration(
+      originalFnName,
+      newParams,
+      t.blockStatement([
+        t.ifStatement(
+          gatingCondition,
+          t.returnStatement(
+            t.callExpression(
+              compiled.id,
+              genNewArgs.map((fn) => fn())
+            )
+          ),
+          t.returnStatement(
+            t.callExpression(
+              unoptimizedFnName,
+              genNewArgs.map((fn) => fn())
+            )
+          )
+        )
+      ])
+    )
+  );
+  fnPath.insertBefore(
+    t.variableDeclaration("const", [
+      t.variableDeclarator(
+        gatingCondition,
+        t.callExpression(t.identifier(gating.importSpecifierName), [])
+      )
+    ])
+  );
+  fnPath.insertBefore(compiled);
+}
+function insertGatedFunctionDeclaration(fnPath, compiled, gating, referencedBeforeDeclaration) {
+  var _a;
+  if (referencedBeforeDeclaration && fnPath.isFunctionDeclaration()) {
+    CompilerError.invariant(compiled.type === "FunctionDeclaration", {
+      reason: "Expected compiled node type to match input type",
+      description: `Got ${compiled.type} but expected FunctionDeclaration`,
+      loc: (_a = fnPath.node.loc) != null ? _a : null
+    });
+    insertAdditionalFunctionDeclaration(fnPath, compiled, gating);
+  } else {
+    const gatingExpression = t.conditionalExpression(
+      t.callExpression(t.identifier(gating.importSpecifierName), []),
+      buildFunctionExpression(compiled),
+      buildFunctionExpression(fnPath.node)
+    );
+    if (fnPath.parentPath.node.type !== "ExportDefaultDeclaration" && fnPath.node.type === "FunctionDeclaration" && fnPath.node.id != null) {
+      fnPath.replaceWith(
+        t.variableDeclaration("const", [
+          t.variableDeclarator(fnPath.node.id, gatingExpression)
+        ])
+      );
+    } else if (fnPath.parentPath.node.type === "ExportDefaultDeclaration" && fnPath.node.type !== "ArrowFunctionExpression" && fnPath.node.id != null) {
+      fnPath.insertAfter(
+        t.exportDefaultDeclaration(t.identifier(fnPath.node.id.name))
+      );
+      fnPath.parentPath.replaceWith(
+        t.variableDeclaration("const", [
+          t.variableDeclarator(
+            t.identifier(fnPath.node.id.name),
+            gatingExpression
+          )
+        ])
+      );
+    } else {
+      fnPath.replaceWith(gatingExpression);
+    }
+  }
+}
+function buildFunctionExpression(node) {
+  var _a, _b;
+  if (node.type === "ArrowFunctionExpression" || node.type === "FunctionExpression") {
+    return node;
+  } else {
+    const fn = {
+      type: "FunctionExpression",
+      async: node.async,
+      generator: node.generator,
+      loc: (_a = node.loc) != null ? _a : null,
+      id: (_b = node.id) != null ? _b : null,
+      params: node.params,
+      body: node.body
+    };
+    return fn;
+  }
+}
+
+// src/Entrypoint/Imports.ts
+var t3 = __toESM(require("@babel/types"));
+
 // src/HIR/HIR.ts
 var t2 = __toESM(require("@babel/types"));
 
@@ -123699,7 +123780,6 @@ var EnvironmentConfigSchema = z.object({
    * original source will be disabled as well.
    */
   disableMemoizationForDebugging: z.boolean().default(false),
-  enableMinimalTransformsForRetry: z.boolean().default(false),
   /**
    * When true, rather using memoized values, the compiler will always re-compute
    * values, and then use a heuristic to compare the memoized value to the newly
@@ -123766,17 +123846,6 @@ var EnvironmentConfigSchema = z.object({
    */
   lowerContextAccess: ExternalFunctionSchema.nullable().default(null)
 });
-var MINIMAL_RETRY_CONFIG = {
-  validateHooksUsage: false,
-  validateRefAccessDuringRender: false,
-  validateNoSetStateInRender: false,
-  validateNoSetStateInPassiveEffects: false,
-  validateNoJSXInTryStatements: false,
-  validateMemoizedEffectDependencies: false,
-  validateNoCapitalizedCalls: null,
-  validateBlocklistedImports: null,
-  enableMinimalTransformsForRetry: true
-};
 var testComplexConfigDefaults = {
   validateNoCapitalizedCalls: [],
   enableChangeDetectionForDebugging: {
@@ -123925,7 +123994,7 @@ function parseConfigPragmaForTests(pragma, defaults) {
 }
 var _globals, _shapes, _moduleTypes, _nextIdentifer, _nextBlock, _nextScope, _scope, _outlinedFunctions, _contextIdentifiers, _hoistedIdentifiers, _Environment_instances, resolveModuleType_fn, isKnownReactModule_fn, getCustomHookType_fn;
 var Environment = class {
-  constructor(scope, fnType, config, contextIdentifiers, logger, filename, code, useMemoCacheIdentifier) {
+  constructor(scope, fnType, compilerMode, config, contextIdentifiers, logger, filename, code, useMemoCacheIdentifier) {
     __privateAdd(this, _Environment_instances);
     __privateAdd(this, _globals);
     __privateAdd(this, _shapes);
@@ -123939,6 +124008,7 @@ var Environment = class {
     __privateAdd(this, _hoistedIdentifiers);
     __privateSet(this, _scope, scope);
     this.fnType = fnType;
+    this.compilerMode = compilerMode;
     this.config = config;
     this.filename = filename;
     this.code = code;
@@ -123983,6 +124053,9 @@ var Environment = class {
     __privateSet(this, _contextIdentifiers, contextIdentifiers);
     __privateSet(this, _hoistedIdentifiers, /* @__PURE__ */ new Set());
   }
+  get isInferredMemoEnabled() {
+    return this.compilerMode !== "no_inferred_memo";
+  }
   get nextIdentifierId() {
     return makeIdentifierId(__privateWrapper(this, _nextIdentifer)._++);
   }
@@ -124197,6 +124270,7 @@ getCustomHookType_fn = function() {
     return DefaultMutatingHook;
   }
 };
+Environment.knownReactModules = ["react", "react-dom"];
 var REANIMATED_MODULE_NAME = "react-native-reanimated";
 function isHookName(name) {
   return /^use[A-Z0-9]/.test(name);
@@ -125090,6 +125164,14 @@ function parsePluginOptions(obj) {
           parsedOptions[key2] = parseTargetConfig(value);
           break;
         }
+        case "gating": {
+          if (value == null) {
+            parsedOptions[key2] = null;
+          } else {
+            parsedOptions[key2] = tryParseExternalFunction(value);
+          }
+          break;
+        }
         default: {
           parsedOptions[key2] = value;
         }
@@ -132339,19 +132421,19 @@ function inferTerminalFunctionEffects(state, block) {
   }
   return functionEffects;
 }
-function raiseFunctionEffectErrors(functionEffects) {
-  functionEffects.forEach((eff) => {
+function transformFunctionEffectErrors(functionEffects) {
+  return functionEffects.map((eff) => {
     switch (eff.kind) {
       case "ReactMutation":
       case "GlobalMutation": {
-        CompilerError.throw(eff.error);
+        return eff.error;
       }
       case "ContextMutation": {
-        CompilerError.throw({
+        return {
           severity: "Invariant" /* Invariant */,
           reason: `Unexpected ContextMutation in top-level function effects`,
           loc: eff.loc
-        });
+        };
       }
       default:
         assertExhaustive(
@@ -132501,8 +132583,9 @@ function inferReferenceEffects(fn, options = { isFunctionExpression: false }) {
   }
   if (options.isFunctionExpression) {
     fn.effects = functionEffects;
-  } else if (!fn.env.config.enableMinimalTransformsForRetry) {
-    raiseFunctionEffectErrors(functionEffects);
+    return [];
+  } else {
+    return transformFunctionEffectErrors(functionEffects);
   }
 }
 var _env3, _values, _variables;
@@ -141794,12 +141877,13 @@ function validateNoImpureFunctionsInRender(fn) {
 }
 
 // src/Entrypoint/Pipeline.ts
-function run(func, config, fnType, useMemoCacheIdentifier, logger, filename, code) {
+function run(func, config, fnType, mode, useMemoCacheIdentifier, logger, filename, code) {
   var _a, _b;
   const contextIdentifiers = findContextIdentifiers(func);
   const env = new Environment(
     func.scope,
     fnType,
+    mode,
     config,
     contextIdentifiers,
     logger,
@@ -141825,7 +141909,7 @@ function runWithEnvironment(func, env) {
   log2({ kind: "hir", name: "PruneMaybeThrows", value: hir });
   validateContextVariableLValues(hir);
   validateUseMemo(hir);
-  if (!env.config.enablePreserveExistingManualUseMemo && !env.config.disableMemoizationForDebugging && !env.config.enableChangeDetectionForDebugging && !env.config.enableMinimalTransformsForRetry) {
+  if (env.isInferredMemoEnabled && !env.config.enablePreserveExistingManualUseMemo && !env.config.disableMemoizationForDebugging && !env.config.enableChangeDetectionForDebugging) {
     dropManualMemoization(hir);
     log2({ kind: "hir", name: "DropManualMemoization", value: hir });
   }
@@ -141848,16 +141932,18 @@ function runWithEnvironment(func, env) {
   log2({ kind: "hir", name: "ConstantPropagation", value: hir });
   inferTypes(hir);
   log2({ kind: "hir", name: "InferTypes", value: hir });
-  if (env.config.validateHooksUsage) {
-    validateHooksUsage(hir);
+  if (env.isInferredMemoEnabled) {
+    if (env.config.validateHooksUsage) {
+      validateHooksUsage(hir);
+    }
+    if (env.config.validateNoCapitalizedCalls) {
+      validateNoCapitalizedCalls(hir);
+    }
   }
   if (env.config.enableFire) {
     transformFire(hir);
     log2({ kind: "hir", name: "TransformFire", value: hir });
   }
-  if (env.config.validateNoCapitalizedCalls) {
-    validateNoCapitalizedCalls(hir);
-  }
   if (env.config.lowerContextAccess) {
     lowerContextAccess(hir, env.config.lowerContextAccess);
   }
@@ -141865,7 +141951,12 @@ function runWithEnvironment(func, env) {
   log2({ kind: "hir", name: "OptimizePropsMethodCalls", value: hir });
   analyseFunctions(hir);
   log2({ kind: "hir", name: "AnalyseFunctions", value: hir });
-  inferReferenceEffects(hir);
+  const fnEffectErrors = inferReferenceEffects(hir);
+  if (env.isInferredMemoEnabled) {
+    if (fnEffectErrors.length > 0) {
+      CompilerError.throw(fnEffectErrors[0]);
+    }
+  }
   log2({ kind: "hir", name: "InferReferenceEffects", value: hir });
   validateLocalsNotReassignedAfterRender(hir);
   deadCodeElimination(hir);
@@ -141878,23 +141969,25 @@ function runWithEnvironment(func, env) {
   log2({ kind: "hir", name: "PruneMaybeThrows", value: hir });
   inferMutableRanges(hir);
   log2({ kind: "hir", name: "InferMutableRanges", value: hir });
-  if (env.config.assertValidMutableRanges) {
-    assertValidMutableRanges(hir);
-  }
-  if (env.config.validateRefAccessDuringRender) {
-    validateNoRefAccessInRender(hir);
-  }
-  if (env.config.validateNoSetStateInRender) {
-    validateNoSetStateInRender(hir);
-  }
-  if (env.config.validateNoSetStateInPassiveEffects) {
-    validateNoSetStateInPassiveEffects(hir);
-  }
-  if (env.config.validateNoJSXInTryStatements) {
-    validateNoJSXInTryStatement(hir);
-  }
-  if (env.config.validateNoImpureFunctionsInRender) {
-    validateNoImpureFunctionsInRender(hir);
+  if (env.isInferredMemoEnabled) {
+    if (env.config.assertValidMutableRanges) {
+      assertValidMutableRanges(hir);
+    }
+    if (env.config.validateRefAccessDuringRender) {
+      validateNoRefAccessInRender(hir);
+    }
+    if (env.config.validateNoSetStateInRender) {
+      validateNoSetStateInRender(hir);
+    }
+    if (env.config.validateNoSetStateInPassiveEffects) {
+      validateNoSetStateInPassiveEffects(hir);
+    }
+    if (env.config.validateNoJSXInTryStatements) {
+      validateNoJSXInTryStatement(hir);
+    }
+    if (env.config.validateNoImpureFunctionsInRender) {
+      validateNoImpureFunctionsInRender(hir);
+    }
   }
   inferReactivePlaces(hir);
   log2({ kind: "hir", name: "InferReactivePlaces", value: hir });
@@ -141910,7 +142003,7 @@ function runWithEnvironment(func, env) {
     name: "PropagatePhiTypes",
     value: hir
   });
-  if (!env.config.enableMinimalTransformsForRetry) {
+  if (env.isInferredMemoEnabled) {
     inferReactiveScopeVariables(hir);
     log2({ kind: "hir", name: "InferReactiveScopeVariables", value: hir });
   }
@@ -142109,11 +142202,12 @@ function runWithEnvironment(func, env) {
   }
   return ast;
 }
-function compileFn(func, config, fnType, useMemoCacheIdentifier, logger, filename, code) {
+function compileFn(func, config, fnType, mode, useMemoCacheIdentifier, logger, filename, code) {
   return run(
     func,
     config,
     fnType,
+    mode,
     useMemoCacheIdentifier,
     logger,
     filename,
@@ -142425,13 +142519,13 @@ function isFilePartOfSources(sources, filename) {
 function compileProgram(program, pass) {
   var _a, _b;
   if (shouldSkipCompilation(program, pass)) {
-    return;
+    return null;
   }
   const environment = pass.opts.environment;
   const restrictedImportsErr = validateRestrictedImports(program, environment);
   if (restrictedImportsErr) {
     handleError(restrictedImportsErr, pass, null);
-    return;
+    return null;
   }
   const useMemoCacheIdentifier = program.scope.generateUidIdentifier("c");
   const suppressions = findProgramSuppressions(
@@ -142469,6 +142563,7 @@ function compileProgram(program, pass) {
       filename: (_b = pass.filename) != null ? _b : null
     })
   );
+  const retryErrors = [];
   const processFn = (fn, fnType) => {
     var _a2, _b2, _c, _d, _e, _f, _g, _h, _i;
     let optInDirectives = [];
@@ -142499,6 +142594,7 @@ function compileProgram(program, pass) {
             fn,
             environment,
             fnType,
+            "all_features",
             useMemoCacheIdentifier.name,
             pass.opts.logger,
             pass.filename,
@@ -142509,14 +142605,23 @@ function compileProgram(program, pass) {
         compileResult = { kind: "error", error: err };
       }
     }
-    if (compileResult.kind === "error" && environment.enableFire) {
+    if (compileResult.kind === "error") {
+      if (optOutDirectives.length > 0) {
+        logError(compileResult.error, pass, (_a2 = fn.node.loc) != null ? _a2 : null);
+      } else {
+        handleError(compileResult.error, pass, (_b2 = fn.node.loc) != null ? _b2 : null);
+      }
+      if (!(environment.enableFire || environment.inferEffectDependencies != null)) {
+        return null;
+      }
       try {
         compileResult = {
           kind: "compile",
           compiledFn: compileFn(
             fn,
-            __spreadValues(__spreadValues({}, environment), MINIMAL_RETRY_CONFIG),
+            environment,
             fnType,
+            "no_inferred_memo",
             useMemoCacheIdentifier.name,
             pass.opts.logger,
             pass.filename,
@@ -142524,16 +142629,11 @@ function compileProgram(program, pass) {
           )
         };
       } catch (err) {
-        compileResult = { kind: "error", error: err };
-      }
-    }
-    if (compileResult.kind === "error") {
-      if (optOutDirectives.length > 0) {
-        logError(compileResult.error, pass, (_a2 = fn.node.loc) != null ? _a2 : null);
-      } else {
-        handleError(compileResult.error, pass, (_b2 = fn.node.loc) != null ? _b2 : null);
+        if (err instanceof CompilerError) {
+          retryErrors.push({ fn, error: err });
+        }
+        return null;
       }
-      return null;
     }
     (_f = pass.opts.logger) == null ? void 0 : _f.logEvent(pass.filename, {
       kind: "CompileSuccess",
@@ -142602,29 +142702,22 @@ function compileProgram(program, pass) {
     program.node.directives
   );
   if (moduleScopeOptOutDirectives.length > 0) {
-    return;
+    return null;
   }
+  let gating = null;
   if (pass.opts.gating != null) {
-    const error = checkFunctionReferencedBeforeDeclarationAtTopLevel(
-      program,
-      compiledFns.map((result) => {
-        return result.originalFn;
-      })
-    );
-    if (error) {
-      handleError(error, pass, null);
-      return;
-    }
+    gating = {
+      gatingFn: pass.opts.gating,
+      referencedBeforeDeclared: getFunctionReferencedBeforeDeclarationAtTopLevel(program, compiledFns)
+    };
   }
   const hasLoweredContextAccess = compiledFns.some(
     (c2) => c2.compiledFn.hasLoweredContextAccess
   );
   const externalFunctions = [];
-  let gating = null;
   try {
-    if (pass.opts.gating != null) {
-      gating = tryParseExternalFunction(pass.opts.gating);
-      externalFunctions.push(gating);
+    if (gating != null) {
+      externalFunctions.push(gating.gatingFn);
     }
     const lowerContextAccess2 = environment.lowerContextAccess;
     if (lowerContextAccess2 && hasLoweredContextAccess) {
@@ -142655,13 +142748,18 @@ function compileProgram(program, pass) {
     }
   } catch (err) {
     handleError(err, pass, null);
-    return;
+    return null;
   }
   for (const result of compiledFns) {
     const { kind, originalFn, compiledFn } = result;
     const transformedFn = createNewFunctionNode(originalFn, compiledFn);
     if (gating != null && kind === "original") {
-      insertGatedFunctionDeclaration(originalFn, transformedFn, gating);
+      insertGatedFunctionDeclaration(
+        originalFn,
+        transformedFn,
+        gating.gatingFn,
+        gating.referencedBeforeDeclared.has(result)
+      );
     } else {
       originalFn.replaceWith(transformedFn);
     }
@@ -142683,6 +142781,7 @@ function compileProgram(program, pass) {
     }
     addImportsToProgram(program, externalFunctions);
   }
+  return { retryErrors };
 }
 function shouldSkipCompilation(program, pass) {
   if (pass.opts.sources) {
@@ -142953,14 +143052,16 @@ function getFunctionName2(path) {
     return null;
   }
 }
-function checkFunctionReferencedBeforeDeclarationAtTopLevel(program, fns) {
-  const fnIds = new Set(
-    fns.map((fn) => getFunctionName2(fn)).filter(
-      (name) => !!name && name.isIdentifier()
-    ).map((name) => name.node)
+function getFunctionReferencedBeforeDeclarationAtTopLevel(program, fns) {
+  const fnNames = new Map(
+    fns.map((fn) => [
+      getFunctionName2(fn.originalFn),
+      fn
+    ]).filter(
+      (entry) => !!entry[0] && entry[0].isIdentifier()
+    ).map((entry) => [entry[0].node.name, { id: entry[0].node, fn: entry[1] }])
   );
-  const fnNames = new Map([...fnIds].map((id) => [id.name, id]));
-  const errors = new CompilerError();
+  const referencedBeforeDeclaration = /* @__PURE__ */ new Set();
   program.traverse({
     TypeAnnotation(path) {
       path.skip();
@@ -142975,31 +143076,21 @@ function checkFunctionReferencedBeforeDeclarationAtTopLevel(program, fns) {
       path.skip();
     },
     Identifier(id) {
-      var _a;
       const fn = fnNames.get(id.node.name);
       if (!fn) {
         return;
       }
-      if (fnIds.has(id.node)) {
-        fnIds.delete(id.node);
+      if (id.node === fn.id) {
         fnNames.delete(id.node.name);
         return;
       }
       const scope = id.scope.getFunctionParent();
       if (scope === null && id.isReferencedIdentifier()) {
-        errors.pushErrorDetail(
-          new CompilerErrorDetail({
-            reason: `Encountered a function used before its declaration, which breaks Forget's gating codegen due to hoisting`,
-            description: `Rewrite the reference to ${fn.name} to not rely on hoisting to fix this issue`,
-            loc: (_a = fn.loc) != null ? _a : null,
-            suggestions: null,
-            severity: "Invariant" /* Invariant */
-          })
-        );
+        referencedBeforeDeclaration.add(fn.fn);
       }
     }
   });
-  return errors.details.length > 0 ? errors : null;
+  return referencedBeforeDeclaration;
 }
 function getReactCompilerRuntimeModule(opts) {
   if (opts.target === "19") {
@@ -143055,6 +143146,181 @@ function injectReanimatedFlag(options) {
   });
 }
 
+// src/Entrypoint/ValidateNoUntransformedReferences.ts
+function throwInvalidReact(options, { logger, filename }) {
+  const detail = __spreadProps(__spreadValues({}, options), {
+    severity: "InvalidReact" /* InvalidReact */
+  });
+  logger == null ? void 0 : logger.logEvent(filename, {
+    kind: "CompileError",
+    fnLoc: null,
+    detail
+  });
+  CompilerError.throw(detail);
+}
+function assertValidEffectImportReference(numArgs, paths, context) {
+  var _a;
+  for (const path of paths) {
+    const parent = path.parentPath;
+    if (parent != null && parent.isCallExpression()) {
+      const args = parent.get("arguments");
+      if (args.length === numArgs) {
+        const maybeErrorDiagnostic = matchCompilerDiagnostic(
+          path,
+          context.transformErrors
+        );
+        throwInvalidReact(
+          {
+            reason: "[InferEffectDependencies] React Compiler is unable to infer dependencies of this effect. This will break your build! To resolve, either pass your own dependency array or fix reported compiler bailout diagnostics.",
+            description: maybeErrorDiagnostic ? `(Bailout reason: ${maybeErrorDiagnostic})` : null,
+            loc: (_a = parent.node.loc) != null ? _a : null
+          },
+          context
+        );
+      }
+    }
+  }
+}
+function assertValidFireImportReference(paths, context) {
+  var _a;
+  if (paths.length > 0) {
+    const maybeErrorDiagnostic = matchCompilerDiagnostic(
+      paths[0],
+      context.transformErrors
+    );
+    throwInvalidReact(
+      {
+        reason: "[Fire] Untransformed reference to compiler-required feature. Either remove this `fire` call or ensure it is successfully transformed by the compiler",
+        description: maybeErrorDiagnostic ? `(Bailout reason: ${maybeErrorDiagnostic})` : null,
+        loc: (_a = paths[0].node.loc) != null ? _a : null
+      },
+      context
+    );
+  }
+}
+function validateNoUntransformedReferences(path, filename, logger, env, transformErrors) {
+  const moduleLoadChecks = /* @__PURE__ */ new Map();
+  if (env.enableFire) {
+    for (const module2 of Environment.knownReactModules) {
+      const react = getOrInsertWith(moduleLoadChecks, module2, () => /* @__PURE__ */ new Map());
+      react.set("fire", assertValidFireImportReference);
+    }
+  }
+  if (env.inferEffectDependencies) {
+    for (const {
+      function: { source: source2, importSpecifierName },
+      numRequiredArgs
+    } of env.inferEffectDependencies) {
+      const module2 = getOrInsertWith(moduleLoadChecks, source2, () => /* @__PURE__ */ new Map());
+      module2.set(
+        importSpecifierName,
+        assertValidEffectImportReference.bind(null, numRequiredArgs)
+      );
+    }
+  }
+  if (moduleLoadChecks.size > 0) {
+    transformProgram(path, moduleLoadChecks, filename, logger, transformErrors);
+  }
+}
+function validateImportSpecifier(specifier, importSpecifierChecks, state) {
+  var _a;
+  const imported = specifier.get("imported");
+  const specifierName = imported.node.type === "Identifier" ? imported.node.name : imported.node.value;
+  const checkFn = importSpecifierChecks.get(specifierName);
+  if (checkFn == null) {
+    return;
+  }
+  if (state.shouldInvalidateScopes) {
+    state.shouldInvalidateScopes = false;
+    state.program.scope.crawl();
+  }
+  const local = specifier.get("local");
+  const binding = local.scope.getBinding(local.node.name);
+  CompilerError.invariant(binding != null, {
+    reason: "Expected binding to be found for import specifier",
+    loc: (_a = local.node.loc) != null ? _a : null
+  });
+  checkFn(binding.referencePaths, state);
+}
+function validateNamespacedImport(specifier, importSpecifierChecks, state) {
+  var _a;
+  if (state.shouldInvalidateScopes) {
+    state.shouldInvalidateScopes = false;
+    state.program.scope.crawl();
+  }
+  const local = specifier.get("local");
+  const binding = local.scope.getBinding(local.node.name);
+  const defaultCheckFn = importSpecifierChecks.get(DEFAULT_EXPORT);
+  CompilerError.invariant(binding != null, {
+    reason: "Expected binding to be found for import specifier",
+    loc: (_a = local.node.loc) != null ? _a : null
+  });
+  const filteredReferences = /* @__PURE__ */ new Map();
+  for (const reference of binding.referencePaths) {
+    if (defaultCheckFn != null) {
+      getOrInsertWith(filteredReferences, defaultCheckFn, () => []).push(
+        reference
+      );
+    }
+    const parent = reference.parentPath;
+    if (parent != null && parent.isMemberExpression() && parent.get("object") === reference) {
+      if (parent.node.computed || parent.node.property.type !== "Identifier") {
+        continue;
+      }
+      const checkFn = importSpecifierChecks.get(parent.node.property.name);
+      if (checkFn != null) {
+        getOrInsertWith(filteredReferences, checkFn, () => []).push(parent);
+      }
+    }
+  }
+  for (const [checkFn, references] of filteredReferences) {
+    checkFn(references, state);
+  }
+}
+function transformProgram(path, moduleLoadChecks, filename, logger, transformErrors) {
+  const traversalState = {
+    shouldInvalidateScopes: true,
+    program: path,
+    filename,
+    logger,
+    transformErrors
+  };
+  path.traverse({
+    ImportDeclaration(path2) {
+      const importSpecifierChecks = moduleLoadChecks.get(
+        path2.node.source.value
+      );
+      if (importSpecifierChecks == null) {
+        return;
+      }
+      const specifiers = path2.get("specifiers");
+      for (const specifier of specifiers) {
+        if (specifier.isImportSpecifier()) {
+          validateImportSpecifier(
+            specifier,
+            importSpecifierChecks,
+            traversalState
+          );
+        } else {
+          validateNamespacedImport(
+            specifier,
+            importSpecifierChecks,
+            traversalState
+          );
+        }
+      }
+    }
+  });
+}
+function matchCompilerDiagnostic(badReference, transformErrors) {
+  for (const { fn, error } of transformErrors) {
+    if (fn.isAncestor(badReference)) {
+      return error.toString();
+    }
+  }
+  return null;
+}
+
 // src/Babel/BabelPlugin.ts
 var ENABLE_REACT_COMPILER_TIMINGS = process.env["ENABLE_REACT_COMPILER_TIMINGS"] === "1";
 function BabelPluginReactCompiler(_babel) {
@@ -143068,7 +143334,7 @@ function BabelPluginReactCompiler(_babel) {
        */
       Program: {
         enter(prog, pass) {
-          var _a, _b, _c;
+          var _a, _b, _c, _d, _e;
           const filename = (_a = pass.filename) != null ? _a : "unknown";
           if (ENABLE_REACT_COMPILER_TIMINGS === true) {
             performance.mark(`${filename}:start`, {
@@ -143087,12 +143353,19 @@ function BabelPluginReactCompiler(_babel) {
               })
             });
           }
-          compileProgram(prog, {
+          const result = compileProgram(prog, {
             opts,
             filename: (_b = pass.filename) != null ? _b : null,
             comments: (_c = pass.file.ast.comments) != null ? _c : [],
             code: pass.file.code
           });
+          validateNoUntransformedReferences(
+            prog,
+            (_d = pass.filename) != null ? _d : null,
+            opts.logger,
+            opts.environment,
+            (_e = result == null ? void 0 : result.retryErrors) != null ? _e : []
+          );
           if (ENABLE_REACT_COMPILER_TIMINGS === true) {
             performance.mark(`${filename}:end`, {
               detail: "BabelPlugin:Program:end"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "babel-plugin-react-compiler",
-  "version": "0.0.0-experimental-d664a4c-20250313",
+  "version": "0.0.0-experimental-3229e95-20250317",
   "description": "Babel plugin for React Compiler.",
   "main": "dist/index.js",
   "license": "MIT",