babel-plugin-react-compiler 0.0.0-experimental-ec81157-20250508 → 0.0.0-experimental-ccdb475-20250513

package/dist/index.d.ts

@@ -1627,22 +1627,6 @@ type Logger = {
 };
 declare function parsePluginOptions(obj: unknown): PluginOptions;
 
-declare class ProgramContext {
-    scope: Scope;
-    reactRuntimeModule: string;
-    hookPattern: string | null;
-    knownReferencedNames: Set<string>;
-    imports: Map<string, Map<string, NonLocalImportSpecifier>>;
-    constructor(program: NodePath$1<t.Program>, reactRuntimeModule: CompilerReactTarget, hookPattern: string | null);
-    isHookName(name: string): boolean;
-    hasReference(name: string): boolean;
-    newUid(name: string): string;
-    addMemoCacheImport(): NonLocalImportSpecifier;
-    addImportSpecifier({ source: module, importSpecifierName: specifier }: ExternalFunction, nameHint?: string): NonLocalImportSpecifier;
-    addNewReference(name: string): void;
-    assertGlobalBinding(name: string, localScope?: Scope): Result<void, CompilerError>;
-}
-
 type CompilerPass = {
     opts: PluginOptions;
     filename: string | null;
@@ -1651,17 +1635,59 @@ type CompilerPass = {
 };
 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 findDirectiveEnablingMemoization(directives: Array<t.Directive>): t.Directive | null;
+declare function findDirectiveDisablingMemoization(directives: Array<t.Directive>): t.Directive | null;
 type BabelFn = NodePath$1<t.FunctionDeclaration> | NodePath$1<t.FunctionExpression> | NodePath$1<t.ArrowFunctionExpression>;
-type CompileProgramResult = {
+type CompileProgramMetadata = {
     retryErrors: Array<{
         fn: BabelFn;
         error: CompilerError;
     }>;
     inferredEffectLocations: Set<t.SourceLocation>;
 };
-declare function compileProgram(program: NodePath$1<t.Program>, pass: CompilerPass): CompileProgramResult | null;
+declare function compileProgram(program: NodePath$1<t.Program>, pass: CompilerPass): CompileProgramMetadata | null;
+
+type SuppressionRange = {
+    disableComment: t.Comment;
+    enableComment: t.Comment | null;
+    source: SuppressionSource;
+};
+type SuppressionSource = 'Eslint' | 'Flow';
+
+type ProgramContextOptions = {
+    program: NodePath$1<t.Program>;
+    suppressions: Array<SuppressionRange>;
+    opts: PluginOptions;
+    filename: string | null;
+    code: string | null;
+    hasModuleScopeOptOut: boolean;
+};
+declare class ProgramContext {
+    scope: Scope;
+    opts: PluginOptions;
+    filename: string | null;
+    code: string | null;
+    reactRuntimeModule: string;
+    suppressions: Array<SuppressionRange>;
+    hasModuleScopeOptOut: boolean;
+    alreadyCompiled: WeakSet<object> | Set<object>;
+    knownReferencedNames: Set<string>;
+    imports: Map<string, Map<string, NonLocalImportSpecifier>>;
+    retryErrors: Array<{
+        fn: BabelFn;
+        error: CompilerError;
+    }>;
+    inferredEffectLocations: Set<t.SourceLocation>;
+    constructor({ program, suppressions, opts, filename, code, hasModuleScopeOptOut, }: ProgramContextOptions);
+    isHookName(name: string): boolean;
+    hasReference(name: string): boolean;
+    newUid(name: string): string;
+    addMemoCacheImport(): NonLocalImportSpecifier;
+    addImportSpecifier({ source: module, importSpecifierName: specifier }: ExternalFunction, nameHint?: string): NonLocalImportSpecifier;
+    addNewReference(name: string): void;
+    assertGlobalBinding(name: string, localScope?: Scope): Result<void, CompilerError>;
+    logEvent(event: LoggerEvent): void;
+}
 
 declare function runBabelPluginReactCompiler(text: string, file: string, language: 'flow' | 'typescript', options: Partial<PluginOptions> | null, includeAst?: boolean): BabelCore.BabelFileResult;
 

package/dist/index.js

@@ -97050,14 +97050,16 @@ function suppressionsToCompilerError(suppressionRanges) {
 var OPT_IN_DIRECTIVES = /* @__PURE__ */ new Set(["use forget", "use memo"]);
 var OPT_OUT_DIRECTIVES = /* @__PURE__ */ new Set(["use no forget", "use no memo"]);
 function findDirectiveEnablingMemoization(directives) {
-  return directives.filter(
+  var _a;
+  return (_a = directives.find(
     (directive2) => OPT_IN_DIRECTIVES.has(directive2.value.value)
-  );
+  )) != null ? _a : null;
 }
 function findDirectiveDisablingMemoization(directives) {
-  return directives.filter(
+  var _a;
+  return (_a = directives.find(
     (directive2) => OPT_OUT_DIRECTIVES.has(directive2.value.value)
-  );
+  )) != null ? _a : null;
 }
 function isCriticalError(err) {
   return !(err instanceof CompilerError) || err.isCritical();
@@ -97070,12 +97072,12 @@ function isConfigError(err) {
   }
   return false;
 }
-function logError(err, pass, fnLoc) {
+function logError(err, context, fnLoc) {
   var _a, _b;
-  if (pass.opts.logger) {
+  if (context.opts.logger) {
     if (err instanceof CompilerError) {
       for (const detail of err.details) {
-        pass.opts.logger.logEvent(pass.filename, {
+        context.opts.logger.logEvent(context.filename, {
           kind: "CompileError",
           fnLoc,
           detail: detail.options
@@ -97088,7 +97090,7 @@ function logError(err, pass, fnLoc) {
       } else {
         stringifiedError = (_b = err == null ? void 0 : err.toString()) != null ? _b : "[ null ]";
       }
-      pass.opts.logger.logEvent(pass.filename, {
+      context.opts.logger.logEvent(context.filename, {
         kind: "PipelineError",
         fnLoc,
         data: stringifiedError
@@ -97096,9 +97098,9 @@ function logError(err, pass, fnLoc) {
     }
   }
 }
-function handleError(err, pass, fnLoc) {
-  logError(err, pass, fnLoc);
-  if (pass.opts.panicThreshold === "all_errors" || pass.opts.panicThreshold === "critical_errors" && isCriticalError(err) || isConfigError(err)) {
+function handleError(err, context, fnLoc) {
+  logError(err, context, fnLoc);
+  if (context.opts.panicThreshold === "all_errors" || context.opts.panicThreshold === "critical_errors" && isCriticalError(err) || isConfigError(err)) {
     throw err;
   }
 }
@@ -97152,7 +97154,6 @@ function createNewFunctionNode(originalFn, compiledFn) {
       );
     }
   }
-  ALREADY_COMPILED.add(transformedFn);
   return transformedFn;
 }
 function insertNewOutlinedFunctionNode(program, originalFn, compiledFn) {
@@ -97199,7 +97200,6 @@ function insertNewOutlinedFunctionNode(program, originalFn, compiledFn) {
     }
   }
 }
-var ALREADY_COMPILED = new (WeakSet != null ? WeakSet : Set)();
 var DEFAULT_ESLINT_SUPPRESSIONS = [
   "react-hooks/exhaustive-deps",
   "react-hooks/rules-of-hooks"
@@ -97216,34 +97216,97 @@ function isFilePartOfSources(sources, filename) {
   return false;
 }
 function compileProgram(program, pass) {
-  var _a, _b;
+  var _a;
   if (shouldSkipCompilation(program, pass)) {
     return null;
   }
-  const environment = pass.opts.environment;
-  const restrictedImportsErr = validateRestrictedImports(program, environment);
+  const restrictedImportsErr = validateRestrictedImports(
+    program,
+    pass.opts.environment
+  );
   if (restrictedImportsErr) {
     handleError(restrictedImportsErr, pass, null);
     return null;
   }
-  const programContext = new ProgramContext(
-    program,
-    pass.opts.target,
-    environment.hookPattern
-  );
   const suppressions = findProgramSuppressions(
     pass.comments,
     (_a = pass.opts.eslintSuppressionRules) != null ? _a : DEFAULT_ESLINT_SUPPRESSIONS,
     pass.opts.flowSuppressions
   );
-  const queue = [];
+  const programContext = new ProgramContext({
+    program,
+    opts: pass.opts,
+    filename: pass.filename,
+    code: pass.code,
+    suppressions,
+    hasModuleScopeOptOut: findDirectiveDisablingMemoization(program.node.directives) != null
+  });
+  const queue = findFunctionsToCompile(
+    program,
+    pass,
+    programContext
+  );
   const compiledFns = [];
+  while (queue.length !== 0) {
+    const current = queue.shift();
+    const compiled = processFn(current.fn, current.fnType, programContext);
+    if (compiled != null) {
+      for (const outlined of compiled.outlined) {
+        CompilerError.invariant(outlined.fn.outlined.length === 0, {
+          reason: "Unexpected nested outlined functions",
+          loc: outlined.fn.loc
+        });
+        const fn = insertNewOutlinedFunctionNode(
+          program,
+          current.fn,
+          outlined.fn
+        );
+        fn.skip();
+        programContext.alreadyCompiled.add(fn.node);
+        if (outlined.type !== null) {
+          queue.push({
+            kind: "outlined",
+            fn,
+            fnType: outlined.type
+          });
+        }
+      }
+      compiledFns.push({
+        kind: current.kind,
+        originalFn: current.fn,
+        compiledFn: compiled
+      });
+    }
+  }
+  if (programContext.hasModuleScopeOptOut) {
+    if (compiledFns.length > 0) {
+      const error = new CompilerError();
+      error.pushErrorDetail(
+        new CompilerErrorDetail({
+          reason: "Unexpected compiled functions when module scope opt-out is present",
+          severity: "Invariant" /* Invariant */,
+          loc: null
+        })
+      );
+      handleError(error, programContext, null);
+    }
+    return null;
+  }
+  applyCompiledFunctions(program, compiledFns, pass, programContext);
+  return {
+    retryErrors: programContext.retryErrors,
+    inferredEffectLocations: programContext.inferredEffectLocations
+  };
+}
+function findFunctionsToCompile(program, pass, programContext) {
+  var _a;
+  const queue = [];
   const traverseFunction2 = (fn, pass2) => {
-    const fnType = getReactFunctionType(fn, pass2, environment);
-    if (fnType === null || ALREADY_COMPILED.has(fn.node)) {
+    const fnType = getReactFunctionType(fn, pass2);
+    if (fnType === null || programContext.alreadyCompiled.has(fn.node)) {
       return;
     }
-    ALREADY_COMPILED.add(fn.node);
+    programContext.alreadyCompiled.add(fn.node);
     fn.skip();
     queue.push({ kind: "original", fn, fnType });
   };
@@ -97251,11 +97314,9 @@ function compileProgram(program, pass) {
     {
       ClassDeclaration(node) {
         node.skip();
-        return;
       },
       ClassExpression(node) {
         node.skip();
-        return;
       },
       FunctionDeclaration: traverseFunction2,
       FunctionExpression: traverseFunction2,
@@ -97263,161 +97324,134 @@ function compileProgram(program, pass) {
     },
     __spreadProps(__spreadValues({}, pass), {
       opts: __spreadValues(__spreadValues({}, pass.opts), pass.opts),
-      filename: (_b = pass.filename) != null ? _b : null
+      filename: (_a = pass.filename) != null ? _a : null
     })
   );
-  const retryErrors = [];
-  const inferredEffectLocations = /* @__PURE__ */ new Set();
-  const processFn = (fn, fnType) => {
-    var _a2, _b2, _c, _d, _e, _f, _g, _h, _i;
-    let optInDirectives = [];
-    let optOutDirectives = [];
-    if (fn.node.body.type === "BlockStatement") {
-      optInDirectives = findDirectiveEnablingMemoization(
-        fn.node.body.directives
-      );
-      optOutDirectives = findDirectiveDisablingMemoization(
-        fn.node.body.directives
-      );
-    }
-    const suppressionsInFunction = filterSuppressionsThatAffectFunction(
-      suppressions,
-      fn
-    );
-    let compileResult;
-    if (suppressionsInFunction.length > 0) {
-      compileResult = {
-        kind: "error",
-        error: suppressionsToCompilerError(suppressionsInFunction)
-      };
+  return queue;
+}
+function processFn(fn, fnType, programContext) {
+  var _a, _b, _c, _d, _e, _f, _g;
+  let directives;
+  if (fn.node.body.type !== "BlockStatement") {
+    directives = { optIn: null, optOut: null };
+  } else {
+    directives = {
+      optIn: findDirectiveEnablingMemoization(fn.node.body.directives),
+      optOut: findDirectiveDisablingMemoization(fn.node.body.directives)
+    };
+  }
+  let compiledFn;
+  const compileResult = tryCompileFunction(fn, fnType, programContext);
+  if (compileResult.kind === "error") {
+    if (directives.optOut != null) {
+      logError(compileResult.error, programContext, (_a = fn.node.loc) != null ? _a : null);
     } else {
-      try {
-        compileResult = {
-          kind: "compile",
-          compiledFn: compileFn(
-            fn,
-            environment,
-            fnType,
-            "all_features",
-            programContext,
-            pass.opts.logger,
-            pass.filename,
-            pass.code
-          )
-        };
-      } 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 (!(environment.enableFire || environment.inferEffectDependencies != null)) {
-        return null;
-      }
-      try {
-        compileResult = {
-          kind: "compile",
-          compiledFn: compileFn(
-            fn,
-            environment,
-            fnType,
-            "no_inferred_memo",
-            programContext,
-            pass.opts.logger,
-            pass.filename,
-            pass.code
-          )
-        };
-        if (!compileResult.compiledFn.hasFireRewrite && !compileResult.compiledFn.hasInferredEffect) {
-          return null;
-        }
-      } catch (err) {
-        if (err instanceof CompilerError) {
-          retryErrors.push({ fn, error: err });
-        }
-        return null;
-      }
+      handleError(compileResult.error, programContext, (_b = fn.node.loc) != null ? _b : null);
     }
-    if (pass.opts.ignoreUseNoForget === false && optOutDirectives.length > 0) {
-      for (const directive2 of optOutDirectives) {
-        (_e = pass.opts.logger) == null ? void 0 : _e.logEvent(pass.filename, {
-          kind: "CompileSkip",
-          fnLoc: (_c = fn.node.body.loc) != null ? _c : null,
-          reason: `Skipped due to '${directive2.value.value}' directive.`,
-          loc: (_d = directive2.loc) != null ? _d : null
-        });
-      }
+    const retryResult = retryCompileFunction(fn, fnType, programContext);
+    if (retryResult == null) {
       return null;
     }
-    (_i = pass.opts.logger) == null ? void 0 : _i.logEvent(pass.filename, {
-      kind: "CompileSuccess",
-      fnLoc: (_f = fn.node.loc) != null ? _f : null,
-      fnName: (_h = (_g = compileResult.compiledFn.id) == null ? void 0 : _g.name) != null ? _h : null,
-      memoSlots: compileResult.compiledFn.memoSlotsUsed,
-      memoBlocks: compileResult.compiledFn.memoBlocks,
-      memoValues: compileResult.compiledFn.memoValues,
-      prunedMemoBlocks: compileResult.compiledFn.prunedMemoBlocks,
-      prunedMemoValues: compileResult.compiledFn.prunedMemoValues
+    compiledFn = retryResult;
+  } else {
+    compiledFn = compileResult.compiledFn;
+  }
+  if (programContext.opts.ignoreUseNoForget === false && directives.optOut != null) {
+    programContext.logEvent({
+      kind: "CompileSkip",
+      fnLoc: (_c = fn.node.body.loc) != null ? _c : null,
+      reason: `Skipped due to '${directives.optOut.value}' directive.`,
+      loc: (_d = directives.optOut.loc) != null ? _d : null
     });
-    if (optInDirectives.length > 0) {
-      return compileResult.compiledFn;
-    } else if (pass.opts.compilationMode === "annotation") {
-      return null;
-    }
-    if (!pass.opts.noEmit) {
-      return compileResult.compiledFn;
-    }
-    for (const loc of compileResult.compiledFn.inferredEffectLocations) {
-      if (loc !== GeneratedSource) inferredEffectLocations.add(loc);
-    }
     return null;
-  };
-  while (queue.length !== 0) {
-    const current = queue.shift();
-    const compiled = processFn(current.fn, current.fnType);
-    if (compiled === null) {
-      continue;
-    }
-    for (const outlined of compiled.outlined) {
-      CompilerError.invariant(outlined.fn.outlined.length === 0, {
-        reason: "Unexpected nested outlined functions",
-        loc: outlined.fn.loc
-      });
-      const fn = insertNewOutlinedFunctionNode(
-        program,
-        current.fn,
-        outlined.fn
-      );
-      fn.skip();
-      ALREADY_COMPILED.add(fn.node);
-      if (outlined.type !== null) {
-        queue.push({
-          kind: "outlined",
-          fn,
-          fnType: outlined.type
-        });
+  }
+  programContext.logEvent({
+    kind: "CompileSuccess",
+    fnLoc: (_e = fn.node.loc) != null ? _e : null,
+    fnName: (_g = (_f = compiledFn.id) == null ? void 0 : _f.name) != null ? _g : null,
+    memoSlots: compiledFn.memoSlotsUsed,
+    memoBlocks: compiledFn.memoBlocks,
+    memoValues: compiledFn.memoValues,
+    prunedMemoBlocks: compiledFn.prunedMemoBlocks,
+    prunedMemoValues: compiledFn.prunedMemoValues
+  });
+  if (programContext.hasModuleScopeOptOut) {
+    return null;
+  } else if (programContext.opts.noEmit) {
+    for (const loc of compiledFn.inferredEffectLocations) {
+      if (loc !== GeneratedSource) {
+        programContext.inferredEffectLocations.add(loc);
       }
     }
-    compiledFns.push({
-      kind: current.kind,
-      compiledFn: compiled,
-      originalFn: current.fn
-    });
+    return null;
+  } else if (programContext.opts.compilationMode === "annotation" && directives.optIn == null) {
+    return null;
+  } else {
+    return compiledFn;
   }
-  const moduleScopeOptOutDirectives = findDirectiveDisablingMemoization(
-    program.node.directives
+}
+function tryCompileFunction(fn, fnType, programContext) {
+  const suppressionsInFunction = filterSuppressionsThatAffectFunction(
+    programContext.suppressions,
+    fn
   );
-  if (moduleScopeOptOutDirectives.length > 0) {
+  if (suppressionsInFunction.length > 0) {
+    return {
+      kind: "error",
+      error: suppressionsToCompilerError(suppressionsInFunction)
+    };
+  }
+  try {
+    return {
+      kind: "compile",
+      compiledFn: compileFn(
+        fn,
+        programContext.opts.environment,
+        fnType,
+        "all_features",
+        programContext,
+        programContext.opts.logger,
+        programContext.filename,
+        programContext.code
+      )
+    };
+  } catch (err) {
+    return { kind: "error", error: err };
+  }
+}
+function retryCompileFunction(fn, fnType, programContext) {
+  const environment = programContext.opts.environment;
+  if (!(environment.enableFire || environment.inferEffectDependencies != null)) {
     return null;
   }
+  try {
+    const retryResult = compileFn(
+      fn,
+      environment,
+      fnType,
+      "no_inferred_memo",
+      programContext,
+      programContext.opts.logger,
+      programContext.filename,
+      programContext.code
+    );
+    if (!retryResult.hasFireRewrite && !retryResult.hasInferredEffect) {
+      return null;
+    }
+    return retryResult;
+  } catch (err) {
+    if (err instanceof CompilerError) {
+      programContext.retryErrors.push({ fn, error: err });
+    }
+    return null;
+  }
+}
+function applyCompiledFunctions(program, compiledFns, pass, programContext) {
   const referencedBeforeDeclared = pass.opts.gating != null ? getFunctionReferencedBeforeDeclarationAtTopLevel(program, compiledFns) : null;
   for (const result of compiledFns) {
     const { kind, originalFn, compiledFn } = result;
     const transformedFn = createNewFunctionNode(originalFn, compiledFn);
+    programContext.alreadyCompiled.add(transformedFn);
     if (referencedBeforeDeclared != null && kind === "original") {
       CompilerError.invariant(pass.opts.gating != null, {
         reason: "Expected 'gating' import to be present",
@@ -97437,7 +97471,6 @@ function compileProgram(program, pass) {
   if (compiledFns.length > 0) {
     addImportsToProgram(program, programContext);
   }
-  return { retryErrors, inferredEffectLocations };
 }
 function shouldSkipCompilation(program, pass) {
   if (pass.opts.sources) {
@@ -97466,11 +97499,11 @@ function shouldSkipCompilation(program, pass) {
   }
   return false;
 }
-function getReactFunctionType(fn, pass, environment) {
+function getReactFunctionType(fn, pass) {
   var _a, _b;
-  const hookPattern = environment.hookPattern;
+  const hookPattern = pass.opts.environment.hookPattern;
   if (fn.node.body.type === "BlockStatement") {
-    if (findDirectiveEnablingMemoization(fn.node.body.directives).length > 0)
+    if (findDirectiveEnablingMemoization(fn.node.body.directives) != null)
       return (_a = getComponentOrHookLike(fn, hookPattern)) != null ? _a : "Other";
   }
   let componentSyntaxType = null;
@@ -97800,20 +97833,42 @@ function validateRestrictedImports(path, { validateBlocklistedImports }) {
   }
 }
 var ProgramContext = class {
-  constructor(program, reactRuntimeModule, hookPattern) {
+  constructor({
+    program,
+    suppressions,
+    opts,
+    filename,
+    code,
+    hasModuleScopeOptOut
+  }) {
+    /*
+     * This is a hack to work around what seems to be a Babel bug. Babel doesn't
+     * consistently respect the `skip()` function to avoid revisiting a node within
+     * a pass, so we use this set to track nodes that we have compiled.
+     */
+    this.alreadyCompiled = new (WeakSet != null ? WeakSet : Set)();
     // known generated or referenced identifiers in the program
     this.knownReferencedNames = /* @__PURE__ */ new Set();
     // generated imports
     this.imports = /* @__PURE__ */ new Map();
-    this.hookPattern = hookPattern;
+    /**
+     * Metadata from compilation
+     */
+    this.retryErrors = [];
+    this.inferredEffectLocations = /* @__PURE__ */ new Set();
     this.scope = program.scope;
-    this.reactRuntimeModule = getReactCompilerRuntimeModule(reactRuntimeModule);
+    this.opts = opts;
+    this.filename = filename;
+    this.code = code;
+    this.reactRuntimeModule = getReactCompilerRuntimeModule(opts.target);
+    this.suppressions = suppressions;
+    this.hasModuleScopeOptOut = hasModuleScopeOptOut;
   }
   isHookName(name) {
-    if (this.hookPattern == null) {
+    if (this.opts.environment.hookPattern == null) {
       return isHookName(name);
     } else {
-      const match = new RegExp(this.hookPattern).exec(name);
+      const match = new RegExp(this.opts.environment.hookPattern).exec(name);
       return match != null && typeof match[1] === "string" && isHookName(match[1]);
     }
   }
@@ -97886,6 +97941,11 @@ var ProgramContext = class {
     });
     return Err(error);
   }
+  logEvent(event) {
+    if (this.opts.logger != null) {
+      this.opts.logger.logEvent(this.filename, event);
+    }
+  }
 };
 function getExistingImports(program) {
   const existingImports = /* @__PURE__ */ new Map();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "babel-plugin-react-compiler",
-  "version": "0.0.0-experimental-ec81157-20250508",
+  "version": "0.0.0-experimental-ccdb475-20250513",
   "description": "Babel plugin for React Compiler.",
   "main": "dist/index.js",
   "license": "MIT",