babel-plugin-react-compiler 19.0.0-beta-decd7b8-20250118 → 19.0.0-beta-714736e-20250131

package/dist/index.js

@@ -121306,8 +121306,16 @@ addObject(BUILTIN_SHAPES, BuiltInMixedReadonlyId, [
   [
     "map",
     addFunction(BUILTIN_SHAPES, [], {
+      /**
+       * Note `map`'s arguments are annotated as Effect.ConditionallyMutate as
+       * calling `<array>.map(fn)` might invoke `fn`, which means replaying its
+       * effects.
+       *
+       * (Note that Effect.Read / Effect.Capture on a function type means
+       * potential data dependency or aliasing respectively.)
+       */
       positionalParams: [],
-      restParam: "read" /* Read */,
+      restParam: "mutate?" /* ConditionallyMutate */,
       returnType: { kind: "Object", shapeId: BuiltInArrayId },
       calleeEffect: "mutate?" /* ConditionallyMutate */,
       returnValueKind: "mutable" /* Mutable */,
@@ -121318,7 +121326,7 @@ addObject(BUILTIN_SHAPES, BuiltInMixedReadonlyId, [
     "flatMap",
     addFunction(BUILTIN_SHAPES, [], {
       positionalParams: [],
-      restParam: "read" /* Read */,
+      restParam: "mutate?" /* ConditionallyMutate */,
       returnType: { kind: "Object", shapeId: BuiltInArrayId },
       calleeEffect: "mutate?" /* ConditionallyMutate */,
       returnValueKind: "mutable" /* Mutable */,
@@ -121329,7 +121337,7 @@ addObject(BUILTIN_SHAPES, BuiltInMixedReadonlyId, [
     "filter",
     addFunction(BUILTIN_SHAPES, [], {
       positionalParams: [],
-      restParam: "read" /* Read */,
+      restParam: "mutate?" /* ConditionallyMutate */,
       returnType: { kind: "Object", shapeId: BuiltInArrayId },
       calleeEffect: "mutate?" /* ConditionallyMutate */,
       returnValueKind: "mutable" /* Mutable */,
@@ -126588,6 +126596,7 @@ 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
@@ -126654,6 +126663,17 @@ 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: {
@@ -133744,7 +133764,7 @@ function codegenInstructionValue(cx, instrValue) {
   }
   return value;
 }
-var STRING_REQUIRES_EXPR_CONTAINER_PATTERN = /[\u{0000}-\u{001F}\u{007F}\u{0080}-\u{FFFF}]|"/u;
+var STRING_REQUIRES_EXPR_CONTAINER_PATTERN = /[\u{0000}-\u{001F}\u{007F}\u{0080}-\u{FFFF}]|"|\\/u;
 function codegenJsxAttribute(cx, attribute) {
   switch (attribute.kind) {
     case "JsxAttribute": {
@@ -133789,7 +133809,7 @@ function codegenJsxAttribute(cx, attribute) {
     }
   }
 }
-var JSX_TEXT_CHILD_REQUIRES_EXPR_CONTAINER_PATTERN = /[<>&]/;
+var JSX_TEXT_CHILD_REQUIRES_EXPR_CONTAINER_PATTERN = /[<>&{}]/;
 function codegenJsxElement(cx, place) {
   const value = codegenPlace(cx, place);
   switch (value.type) {
@@ -134985,11 +135005,15 @@ function inferOperandEffect(state, place) {
       if (isRefOrRefValue(place.identifier)) {
         break;
       } else if (value.kind === "context" /* Context */) {
+        CompilerError.invariant(value.context.size > 0, {
+          reason: "[InferFunctionEffects] Expected Context-kind value's capture list to be non-empty.",
+          loc: place.loc
+        });
         return {
           kind: "ContextMutation",
           loc: place.loc,
           effect: place.effect,
-          places: value.context.size === 0 ? /* @__PURE__ */ new Set([place]) : value.context
+          places: value.context
         };
       } else if (value.kind !== "mutable" /* Mutable */ && // We ignore mutations of primitives since this is not a React-specific problem
       value.kind !== "primitive" /* Primitive */) {
@@ -135307,7 +135331,7 @@ function inferReferenceEffects(fn, options = { isFunctionExpression: false }) {
   }
   if (options.isFunctionExpression) {
     fn.effects = functionEffects;
-  } else {
+  } else if (!fn.env.config.enableMinimalTransformsForRetry) {
     raiseFunctionEffectErrors(functionEffects);
   }
 }
@@ -135744,10 +135768,11 @@ function inferBlock(env, state, block, functionEffects) {
         break;
       }
       case "ArrayExpression": {
-        const valueKind = hasContextRefOperand(state, instrValue) ? {
+        const contextRefOperands = getContextRefOperand(state, instrValue);
+        const valueKind = contextRefOperands.length > 0 ? {
           kind: "context" /* Context */,
           reason: /* @__PURE__ */ new Set(["other" /* Other */]),
-          context: /* @__PURE__ */ new Set()
+          context: new Set(contextRefOperands)
         } : {
           kind: "mutable" /* Mutable */,
           reason: /* @__PURE__ */ new Set(["other" /* Other */]),
@@ -135788,10 +135813,11 @@ function inferBlock(env, state, block, functionEffects) {
         break;
       }
       case "ObjectExpression": {
-        const valueKind = hasContextRefOperand(state, instrValue) ? {
+        const contextRefOperands = getContextRefOperand(state, instrValue);
+        const valueKind = contextRefOperands.length > 0 ? {
           kind: "context" /* Context */,
           reason: /* @__PURE__ */ new Set(["other" /* Other */]),
-          context: /* @__PURE__ */ new Set()
+          context: new Set(contextRefOperands)
         } : {
           kind: "mutable" /* Mutable */,
           reason: /* @__PURE__ */ new Set(["other" /* Other */]),
@@ -136381,11 +136407,17 @@ function inferBlock(env, state, block, functionEffects) {
       }
       case "LoadLocal": {
         const lvalue = instr.lvalue;
-        const effect = state.isDefined(lvalue) && state.kind(lvalue).kind === "context" /* Context */ ? "mutate?" /* ConditionallyMutate */ : "capture" /* Capture */;
+        CompilerError.invariant(
+          !(state.isDefined(lvalue) && state.kind(lvalue).kind === "context" /* Context */),
+          {
+            reason: "[InferReferenceEffects] Unexpected LoadLocal with context kind",
+            loc: lvalue.loc
+          }
+        );
         state.referenceAndRecordEffects(
           freezeActions,
           instrValue.place,
-          effect,
+          "capture" /* Capture */,
           "other" /* Other */
         );
         lvalue.effect = "mutate?" /* ConditionallyMutate */;
@@ -136639,13 +136671,14 @@ function inferBlock(env, state, block, functionEffects) {
     ({ values, reason }) => state.freezeValues(values, reason)
   );
 }
-function hasContextRefOperand(state, instrValue) {
+function getContextRefOperand(state, instrValue) {
+  const result = [];
   for (const place of eachInstructionValueOperand(instrValue)) {
     if (state.isDefined(place) && state.kind(place).kind === "context" /* Context */) {
-      return true;
+      result.push(place);
     }
   }
-  return false;
+  return result;
 }
 function getFunctionCallSignature(env, type) {
   if (type.kind !== "Function") {
@@ -144673,7 +144706,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) {
+  if (!env.config.enablePreserveExistingManualUseMemo && !env.config.disableMemoizationForDebugging && !env.config.enableChangeDetectionForDebugging && !env.config.enableMinimalTransformsForRetry) {
     dropManualMemoization(hir);
     log2({ kind: "hir", name: "DropManualMemoization", value: hir });
   }
@@ -144758,8 +144791,10 @@ function runWithEnvironment(func, env) {
     name: "PropagatePhiTypes",
     value: hir
   });
-  inferReactiveScopeVariables(hir);
-  log2({ kind: "hir", name: "InferReactiveScopeVariables", value: hir });
+  if (!env.config.enableMinimalTransformsForRetry) {
+    inferReactiveScopeVariables(hir);
+    log2({ kind: "hir", name: "InferReactiveScopeVariables", value: hir });
+  }
   const fbtOperands = memoizeFbtAndMacroOperandsInSameScope(hir);
   log2({
     kind: "hir",
@@ -145322,52 +145357,75 @@ function compileProgram(program, pass) {
         fn.node.body.directives
       );
     }
-    let compiledFn;
-    try {
-      const suppressionsInFunction = filterSuppressionsThatAffectFunction(
-        suppressions,
-        fn
-      );
-      if (suppressionsInFunction.length > 0) {
-        const lintError = suppressionsToCompilerError(suppressionsInFunction);
-        if (optOutDirectives.length > 0) {
-          logError(lintError, pass, fn.node.loc ?? null);
-        } else {
-          handleError(lintError, pass, fn.node.loc ?? null);
-        }
-        return null;
+    const suppressionsInFunction = filterSuppressionsThatAffectFunction(
+      suppressions,
+      fn
+    );
+    let compileResult;
+    if (suppressionsInFunction.length > 0) {
+      compileResult = {
+        kind: "error",
+        error: suppressionsToCompilerError(suppressionsInFunction)
+      };
+    } else {
+      try {
+        compileResult = {
+          kind: "compile",
+          compiledFn: compileFn(
+            fn,
+            environment,
+            fnType,
+            useMemoCacheIdentifier.name,
+            pass.opts.logger,
+            pass.filename,
+            pass.code
+          )
+        };
+      } catch (err) {
+        compileResult = { kind: "error", error: err };
       }
-      compiledFn = compileFn(
-        fn,
-        environment,
-        fnType,
-        useMemoCacheIdentifier.name,
-        pass.opts.logger,
-        pass.filename,
-        pass.code
-      );
-      pass.opts.logger?.logEvent(pass.filename, {
-        kind: "CompileSuccess",
-        fnLoc: fn.node.loc ?? null,
-        fnName: compiledFn.id?.name ?? null,
-        memoSlots: compiledFn.memoSlotsUsed,
-        memoBlocks: compiledFn.memoBlocks,
-        memoValues: compiledFn.memoValues,
-        prunedMemoBlocks: compiledFn.prunedMemoBlocks,
-        prunedMemoValues: compiledFn.prunedMemoValues
-      });
-    } catch (err) {
-      if (fn.node.body.type === "BlockStatement") {
-        if (optOutDirectives.length > 0) {
-          logError(err, pass, fn.node.loc ?? null);
-          return null;
-        }
+    }
+    if (compileResult.kind === "error" && environment.enableFire) {
+      try {
+        compileResult = {
+          kind: "compile",
+          compiledFn: compileFn(
+            fn,
+            {
+              ...environment,
+              ...MINIMAL_RETRY_CONFIG
+            },
+            fnType,
+            useMemoCacheIdentifier.name,
+            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, fn.node.loc ?? null);
+      } else {
+        handleError(compileResult.error, pass, fn.node.loc ?? null);
       }
-      handleError(err, pass, fn.node.loc ?? null);
       return null;
     }
+    pass.opts.logger?.logEvent(pass.filename, {
+      kind: "CompileSuccess",
+      fnLoc: fn.node.loc ?? null,
+      fnName: compileResult.compiledFn.id?.name ?? null,
+      memoSlots: compileResult.compiledFn.memoSlotsUsed,
+      memoBlocks: compileResult.compiledFn.memoBlocks,
+      memoValues: compileResult.compiledFn.memoValues,
+      prunedMemoBlocks: compileResult.compiledFn.prunedMemoBlocks,
+      prunedMemoValues: compileResult.compiledFn.prunedMemoValues
+    });
     if (optInDirectives.length > 0) {
-      return compiledFn;
+      return compileResult.compiledFn;
     } else if (pass.opts.compilationMode === "annotation") {
       return null;
     }
@@ -145383,7 +145441,7 @@ function compileProgram(program, pass) {
       return null;
     }
     if (!pass.opts.noEmit) {
-      return compiledFn;
+      return compileResult.compiledFn;
     }
     return null;
   };