babel-plugin-react-compiler 19.0.0-beta-e552027-20250112 → 19.0.0-beta-decd7b8-20250118

package/dist/index.js

@@ -125468,6 +125468,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 +125577,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 +126129,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 +126404,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
@@ -144552,6 +144614,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 +144741,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 +145740,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;
 }