babel-plugin-react-compiler 19.0.0-beta-e552027-20250112 → 19.0.0-beta-27714ef-20250124

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 */,
@@ -125468,6 +125476,48 @@ var TYPED_GLOBALS = [
       ]
     ])
   ],
+  [
+    "performance",
+    addObject(DEFAULT_SHAPES, "performance", [
+      // Static methods (TODO)
+      [
+        "now",
+        // Date.now()
+        addFunction(DEFAULT_SHAPES, [], {
+          positionalParams: [],
+          restParam: "read" /* Read */,
+          returnType: { kind: "Poly" },
+          // TODO: could be Primitive, but that would change existing compilation
+          calleeEffect: "read" /* Read */,
+          returnValueKind: "mutable" /* Mutable */,
+          // same here
+          impure: true,
+          canonicalName: "performance.now"
+        })
+      ]
+    ])
+  ],
+  [
+    "Date",
+    addObject(DEFAULT_SHAPES, "Date", [
+      // Static methods (TODO)
+      [
+        "now",
+        // Date.now()
+        addFunction(DEFAULT_SHAPES, [], {
+          positionalParams: [],
+          restParam: "read" /* Read */,
+          returnType: { kind: "Poly" },
+          // TODO: could be Primitive, but that would change existing compilation
+          calleeEffect: "read" /* Read */,
+          returnValueKind: "mutable" /* Mutable */,
+          // same here
+          impure: true,
+          canonicalName: "Date.now"
+        })
+      ]
+    ])
+  ],
   [
     "Math",
     addObject(DEFAULT_SHAPES, "Math", [
@@ -125535,6 +125585,20 @@ var TYPED_GLOBALS = [
           calleeEffect: "read" /* Read */,
           returnValueKind: "primitive" /* Primitive */
         })
+      ],
+      [
+        "random",
+        addFunction(DEFAULT_SHAPES, [], {
+          positionalParams: [],
+          restParam: "read" /* Read */,
+          returnType: { kind: "Poly" },
+          // TODO: could be Primitive, but that would change existing compilation
+          calleeEffect: "read" /* Read */,
+          returnValueKind: "mutable" /* Mutable */,
+          // same here
+          impure: true,
+          canonicalName: "Math.random"
+        })
       ]
     ])
   ],
@@ -126073,7 +126137,9 @@ var FunctionTypeSchema = z.object({
   returnType: z.lazy(() => TypeSchema),
   returnValueKind: ValueKindSchema,
   noAlias: z.boolean().nullable().optional(),
-  mutableOnlyIfOperandsAreMutable: z.boolean().nullable().optional()
+  mutableOnlyIfOperandsAreMutable: z.boolean().nullable().optional(),
+  impure: z.boolean().nullable().optional(),
+  canonicalName: z.string().nullable().optional()
 });
 var HookTypeSchema = z.object({
   kind: z.literal("hook"),
@@ -126346,6 +126412,10 @@ var EnvironmentConfigSchema = z.object({
    */
   validateNoCapitalizedCalls: z.nullable(z.array(z.string())).default(null),
   validateBlocklistedImports: z.nullable(z.array(z.string())).default(null),
+  /**
+   * Validate against impure functions called during render
+   */
+  validateNoImpureFunctionsInRender: z.boolean().default(false),
   /*
    * When enabled, the compiler assumes that hooks follow the Rules of React:
    * - Hooks may memoize computation based on any of their parameters, thus
@@ -133682,7 +133752,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": {
@@ -133727,7 +133797,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) {
@@ -134923,11 +134993,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 */) {
@@ -135682,10 +135756,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 */]),
@@ -135726,10 +135801,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 */]),
@@ -136319,11 +136395,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 */;
@@ -136577,13 +136659,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") {
@@ -144552,6 +144635,35 @@ function rewriteInstructions(rewriteInstrs, instructions) {
   return instructions;
 }
 
+// src/Validation/ValiateNoImpureFunctionsInRender.ts
+function validateNoImpureFunctionsInRender(fn) {
+  const errors = new CompilerError();
+  for (const [, block] of fn.body.blocks) {
+    for (const instr of block.instructions) {
+      const value = instr.value;
+      if (value.kind === "MethodCall" || value.kind == "CallExpression") {
+        const callee = value.kind === "MethodCall" ? value.property : value.callee;
+        const signature = getFunctionCallSignature(
+          fn.env,
+          callee.identifier.type
+        );
+        if (signature != null && signature.impure === true) {
+          errors.push({
+            reason: "Calling an impure function can produce unstable results. (https://react.dev/reference/rules/components-and-hooks-must-be-pure#components-and-hooks-must-be-idempotent)",
+            description: signature.canonicalName != null ? `\`${signature.canonicalName}\` is an impure function whose results may change on every call` : null,
+            severity: "InvalidReact" /* InvalidReact */,
+            loc: callee.loc,
+            suggestions: null
+          });
+        }
+      }
+    }
+  }
+  if (errors.hasErrors()) {
+    throw errors;
+  }
+}
+
 // src/Entrypoint/Pipeline.ts
 function run(func, config, fnType, useMemoCacheIdentifier, logger, filename, code) {
   const contextIdentifiers = findContextIdentifiers(func);
@@ -144650,6 +144762,9 @@ function runWithEnvironment(func, env) {
   if (env.config.validateNoJSXInTryStatements) {
     validateNoJSXInTryStatement(hir);
   }
+  if (env.config.validateNoImpureFunctionsInRender) {
+    validateNoImpureFunctionsInRender(hir);
+  }
   inferReactivePlaces(hir);
   log2({ kind: "hir", name: "InferReactivePlaces", value: hir });
   rewriteInstructionKindsBasedOnReassignment(hir);
@@ -145646,9 +145761,11 @@ function returnsNonNode(node) {
         }
       }
     },
+    // Skip traversing all nested functions and their return statements
     ArrowFunctionExpression: skipNestedFunctions(node),
     FunctionExpression: skipNestedFunctions(node),
-    FunctionDeclaration: skipNestedFunctions(node)
+    FunctionDeclaration: skipNestedFunctions(node),
+    ObjectMethod: (node2) => node2.skip()
   });
   return !hasReturn || returnsNonNode2;
 }