[compiler] Cleanup diagnostic messages

Minor sytlistic cleanup

.eslintrc.js

@@ -608,7 +608,6 @@ module.exports = {
     symbol: 'readonly',
     SyntheticEvent: 'readonly',
     SyntheticMouseEvent: 'readonly',
-    SyntheticPointerEvent: 'readonly',
     Thenable: 'readonly',
     TimeoutID: 'readonly',
     WheelEventHandler: 'readonly',

CHANGELOG.md

@@ -1,8 +1,3 @@
-## 19.1.1 (July 28, 2025)
-
-### React
-* Fixed Owner Stacks to work with ES2015 function.name semantics ([#33680](https://github.com/facebook/react/pull/33680) by @hoxyq)
-
 ## 19.1.0 (March 28, 2025)
 
 ### Owner Stack

compiler/apps/playground/__tests__/e2e/__snapshots__/page.spec.ts/compilationMode-all-output.txt

@@ -1,5 +1,5 @@
 import { c as _c } from "react/compiler-runtime"; // 
-@compilationMode:"all"
+        @compilationMode:"all"
 function nonReactFn() {
   const $ = _c(1);
   let t0;

compiler/apps/playground/components/Editor/EditorImpl.tsx

@@ -11,7 +11,6 @@ import * as t from '@babel/types';
 import BabelPluginReactCompiler, {
   CompilerError,
   CompilerErrorDetail,
-  CompilerDiagnostic,
   Effect,
   ErrorSeverity,
   parseConfigPragmaForTests,
@@ -142,13 +141,10 @@ const COMMON_HOOKS: Array<[string, Hook]> = [
   ],
 ];
 
-function compile(
-  source: string,
-  mode: 'compiler' | 'linter',
-): [CompilerOutput, 'flow' | 'typescript'] {
+function compile(source: string): [CompilerOutput, 'flow' | 'typescript'] {
   const results = new Map<string, Array<PrintedCompilerPipelineValue>>();
   const error = new CompilerError();
-  const otherErrors: Array<CompilerErrorDetail | CompilerDiagnostic> = [];
+  const otherErrors: Array<CompilerErrorDetail> = [];
   const upsert: (result: PrintedCompilerPipelineValue) => void = result => {
     const entry = results.get(result.name);
     if (Array.isArray(entry)) {
@@ -207,23 +203,6 @@ function compile(
     };
     const parsedOptions = parseConfigPragmaForTests(pragma, {
       compilationMode: 'infer',
-      environment:
-        mode === 'linter'
-          ? {
-              // enabled in compiler
-              validateRefAccessDuringRender: false,
-              // enabled in linter
-              validateNoSetStateInRender: true,
-              validateNoSetStateInEffects: true,
-              validateNoJSXInTryStatements: true,
-              validateNoImpureFunctionsInRender: true,
-              validateStaticComponents: true,
-              validateNoFreezingKnownMutableFunctions: true,
-              validateNoVoidUseMemo: true,
-            }
-          : {
-              /* use defaults for compiler mode */
-            },
     });
     const opts: PluginOptions = parsePluginOptions({
       ...parsedOptions,
@@ -235,7 +214,7 @@ function compile(
         debugLogIRs: logIR,
         logEvent: (_filename: string | null, event: LoggerEvent) => {
           if (event.kind === 'CompileError') {
-            otherErrors.push(event.detail);
+            otherErrors.push(new CompilerErrorDetail(event.detail));
           }
         },
       },
@@ -247,7 +226,7 @@ function compile(
      * (i.e. object shape that is not CompilerError)
      */
     if (err instanceof CompilerError && err.details.length > 0) {
-      error.merge(err);
+      error.details.push(...err.details);
     } else {
       /**
        * Handle unexpected failures by logging (to get a stack trace)
@@ -266,15 +245,12 @@ function compile(
   }
   // Only include logger errors if there weren't other errors
   if (!error.hasErrors() && otherErrors.length !== 0) {
-    otherErrors.forEach(e => error.details.push(e));
+    otherErrors.forEach(e => error.push(e));
   }
   if (error.hasErrors()) {
-    return [{kind: 'err', results, error}, language];
+    return [{kind: 'err', results, error: error}, language];
   }
-  return [
-    {kind: 'ok', results, transformOutput, errors: error.details},
-    language,
-  ];
+  return [{kind: 'ok', results, transformOutput}, language];
 }
 
 export default function Editor(): JSX.Element {
@@ -283,11 +259,7 @@ export default function Editor(): JSX.Element {
   const dispatchStore = useStoreDispatch();
   const {enqueueSnackbar} = useSnackbar();
   const [compilerOutput, language] = useMemo(
-    () => compile(deferredStore.source, 'compiler'),
-    [deferredStore.source],
-  );
-  const [linterOutput] = useMemo(
-    () => compile(deferredStore.source, 'linter'),
+    () => compile(deferredStore.source),
     [deferredStore.source],
   );
 
@@ -313,26 +285,19 @@ export default function Editor(): JSX.Element {
     });
   });
 
-  let mergedOutput: CompilerOutput;
-  let errors: Array<CompilerErrorDetail | CompilerDiagnostic>;
-  if (compilerOutput.kind === 'ok') {
-    errors = linterOutput.kind === 'ok' ? [] : linterOutput.error.details;
-    mergedOutput = {
-      ...compilerOutput,
-      errors,
-    };
-  } else {
-    mergedOutput = compilerOutput;
-    errors = compilerOutput.error.details;
-  }
   return (
     <>
       <div className="relative flex basis top-14">
         <div className={clsx('relative sm:basis-1/4')}>
-          <Input language={language} errors={errors} />
+          <Input
+            language={language}
+            errors={
+              compilerOutput.kind === 'err' ? compilerOutput.error.details : []
+            }
+          />
         </div>
         <div className={clsx('flex sm:flex flex-wrap')}>
-          <Output store={deferredStore} compilerOutput={mergedOutput} />
+          <Output store={deferredStore} compilerOutput={compilerOutput} />
         </div>
       </div>
     </>

compiler/apps/playground/components/Editor/Input.tsx

@@ -36,18 +36,13 @@ export default function Input({errors, language}: Props): JSX.Element {
     const uri = monaco.Uri.parse(`file:///index.js`);
     const model = monaco.editor.getModel(uri);
     invariant(model, 'Model must exist for the selected input file.');
-    renderReactCompilerMarkers({
-      monaco,
-      model,
-      details: errors,
-      source: store.source,
-    });
+    renderReactCompilerMarkers({monaco, model, details: errors});
     /**
      * N.B. that `tabSize` is a model property, not an editor property.
      * So, the tab size has to be set per model.
      */
     model.updateOptions({tabSize: 2});
-  }, [monaco, errors, store.source]);
+  }, [monaco, errors]);
 
   useEffect(() => {
     /**

compiler/apps/playground/components/Editor/Output.tsx

@@ -11,11 +11,7 @@ import {
   InformationCircleIcon,
 } from '@heroicons/react/outline';
 import MonacoEditor, {DiffEditor} from '@monaco-editor/react';
-import {
-  CompilerErrorDetail,
-  CompilerDiagnostic,
-  type CompilerError,
-} from 'babel-plugin-react-compiler';
+import {type CompilerError} from 'babel-plugin-react-compiler';
 import parserBabel from 'prettier/plugins/babel';
 import * as prettierPluginEstree from 'prettier/plugins/estree';
 import * as prettier from 'prettier/standalone';
@@ -48,7 +44,6 @@ export type CompilerOutput =
       kind: 'ok';
       transformOutput: CompilerTransformOutput;
       results: Map<string, Array<PrintedCompilerPipelineValue>>;
-      errors: Array<CompilerErrorDetail | CompilerDiagnostic>;
     }
   | {
       kind: 'err';
@@ -128,36 +123,10 @@ async function tabify(
       parser: transformOutput.language === 'flow' ? 'babel-flow' : 'babel-ts',
       plugins: [parserBabel, prettierPluginEstree],
     });
-
-    let output: string;
-    let language: string;
-    if (compilerOutput.errors.length === 0) {
-      output = code;
-      language = 'javascript';
-    } else {
-      language = 'markdown';
-      output = `
-# Summary
-
-React Compiler compiled this function successfully, but there are lint errors that indicate potential issues with the original code.
-
-## ${compilerOutput.errors.length} Lint Errors
-
-${compilerOutput.errors.map(e => e.printErrorMessage(source, {eslint: false})).join('\n\n')}
-
-## Output
-
-\`\`\`js
-${code}
-\`\`\`
-`.trim();
-    }
-
     reorderedTabs.set(
-      'Output',
+      'JS',
       <TextTabContent
-        output={output}
-        language={language}
+        output={code}
         diff={null}
         showInfoPanel={false}></TextTabContent>,
     );
@@ -173,18 +142,6 @@ ${code}
         </>,
       );
     }
-  } else if (compilerOutput.kind === 'err') {
-    const errors = compilerOutput.error.printErrorMessage(source, {
-      eslint: false,
-    });
-    reorderedTabs.set(
-      'Output',
-      <TextTabContent
-        output={errors}
-        language="markdown"
-        diff={null}
-        showInfoPanel={false}></TextTabContent>,
-    );
   }
   tabs.forEach((tab, name) => {
     reorderedTabs.set(name, tab);
@@ -205,32 +162,17 @@ function getSourceMapUrl(code: string, map: string): string | null {
 }
 
 function Output({store, compilerOutput}: Props): JSX.Element {
-  const [tabsOpen, setTabsOpen] = useState<Set<string>>(
-    () => new Set(['Output']),
-  );
+  const [tabsOpen, setTabsOpen] = useState<Set<string>>(() => new Set(['JS']));
   const [tabs, setTabs] = useState<Map<string, React.ReactNode>>(
     () => new Map(),
   );
-
-  /*
-   * Update the active tab back to the output or errors tab when the compilation state
-   * changes between success/failure.
-   */
-  const [previousOutputKind, setPreviousOutputKind] = useState(
-    compilerOutput.kind,
-  );
-  if (compilerOutput.kind !== previousOutputKind) {
-    setPreviousOutputKind(compilerOutput.kind);
-    setTabsOpen(new Set(['Output']));
-  }
-
   useEffect(() => {
     tabify(store.source, compilerOutput).then(tabs => {
       setTabs(tabs);
     });
   }, [store.source, compilerOutput]);
 
-  const changedPasses: Set<string> = new Set(['Output', 'HIR']); // Initial and final passes should always be bold
+  const changedPasses: Set<string> = new Set(['JS', 'HIR']); // Initial and final passes should always be bold
   let lastResult: string = '';
   for (const [passName, results] of compilerOutput.results) {
     for (const result of results) {
@@ -254,6 +196,20 @@ function Output({store, compilerOutput}: Props): JSX.Element {
         tabs={tabs}
         changedPasses={changedPasses}
       />
+      {compilerOutput.kind === 'err' ? (
+        <div
+          className="flex flex-wrap absolute bottom-0 bg-white grow border-y border-grey-200 transition-all ease-in"
+          style={{width: 'calc(100vw - 650px)'}}>
+          <div className="w-full p-4 basis-full border-b">
+            <h2>COMPILER ERRORS</h2>
+          </div>
+          <pre
+            className="p-4 basis-full text-red-600 overflow-y-scroll whitespace-pre-wrap"
+            style={{width: 'calc(100vw - 650px)', height: '150px'}}>
+            <code>{compilerOutput.error.toString()}</code>
+          </pre>
+        </div>
+      ) : null}
     </>
   );
 }
@@ -262,12 +218,10 @@ function TextTabContent({
   output,
   diff,
   showInfoPanel,
-  language,
 }: {
   output: string;
   diff: string | null;
   showInfoPanel: boolean;
-  language: string;
 }): JSX.Element {
   const [diffMode, setDiffMode] = useState(false);
   return (
@@ -318,7 +272,7 @@ function TextTabContent({
         />
       ) : (
         <MonacoEditor
-          language={language ?? 'javascript'}
+          defaultLanguage="javascript"
           value={output}
           options={{
             ...monacoOptions,

compiler/apps/playground/components/Editor/monacoOptions.ts

@@ -28,5 +28,5 @@ export const monacoOptions: Partial<EditorProps['options']> = {
 
   automaticLayout: true,
   wordWrap: 'on',
-  wrappingIndent: 'same',
+  wrappingIndent: 'deepIndent',
 };

compiler/apps/playground/lib/reactCompilerMonacoDiagnostics.ts

@@ -6,11 +6,7 @@
  */
 
 import {Monaco} from '@monaco-editor/react';
-import {
-  CompilerDiagnostic,
-  CompilerErrorDetail,
-  ErrorSeverity,
-} from 'babel-plugin-react-compiler';
+import {CompilerErrorDetail, ErrorSeverity} from 'babel-plugin-react-compiler';
 import {MarkerSeverity, type editor} from 'monaco-editor';
 
 function mapReactCompilerSeverityToMonaco(
@@ -26,46 +22,38 @@ function mapReactCompilerSeverityToMonaco(
 }
 
 function mapReactCompilerDiagnosticToMonacoMarker(
-  detail: CompilerErrorDetail | CompilerDiagnostic,
+  detail: CompilerErrorDetail,
   monaco: Monaco,
-  source: string,
 ): editor.IMarkerData | null {
-  const loc = detail.primaryLocation();
-  if (loc == null || typeof loc === 'symbol') {
+  if (detail.loc == null || typeof detail.loc === 'symbol') {
     return null;
   }
   const severity = mapReactCompilerSeverityToMonaco(detail.severity, monaco);
-  let message = detail.printErrorMessage(source, {eslint: true});
+  let message = detail.printErrorMessage();
   return {
     severity,
     message,
-    startLineNumber: loc.start.line,
-    startColumn: loc.start.column + 1,
-    endLineNumber: loc.end.line,
-    endColumn: loc.end.column + 1,
+    startLineNumber: detail.loc.start.line,
+    startColumn: detail.loc.start.column + 1,
+    endLineNumber: detail.loc.end.line,
+    endColumn: detail.loc.end.column + 1,
   };
 }
 
 type ReactCompilerMarkerConfig = {
   monaco: Monaco;
   model: editor.ITextModel;
-  details: Array<CompilerErrorDetail | CompilerDiagnostic>;
-  source: string;
+  details: Array<CompilerErrorDetail>;
 };
 let decorations: Array<string> = [];
 export function renderReactCompilerMarkers({
   monaco,
   model,
   details,
-  source,
 }: ReactCompilerMarkerConfig): void {
   const markers: Array<editor.IMarkerData> = [];
   for (const detail of details) {
-    const marker = mapReactCompilerDiagnosticToMonacoMarker(
-      detail,
-      monaco,
-      source,
-    );
+    const marker = mapReactCompilerDiagnosticToMonacoMarker(detail, monaco);
     if (marker == null) {
       continue;
     }

compiler/packages/babel-plugin-react-compiler/src/Babel/BabelPlugin.ts

@@ -84,7 +84,9 @@ export default function BabelPluginReactCompiler(
             }
           } catch (e) {
             if (e instanceof CompilerError) {
-              throw e.withPrintedMessage(pass.file.code, {eslint: false});
+              throw new Error(
+                e.printErrorMessage(pass.file.code, {eslint: false}),
+              );
             }
             throw e;
           }

compiler/packages/babel-plugin-react-compiler/src/CompilerError.ts

@@ -262,7 +262,6 @@ export class CompilerErrorDetail {
 
 export class CompilerError extends Error {
   details: Array<CompilerErrorDetail | CompilerDiagnostic> = [];
-  printedMessage: string | null = null;
 
   static invariant(
     condition: unknown,
@@ -348,29 +347,18 @@ export class CompilerError extends Error {
   }
 
   override get message(): string {
-    return this.printedMessage ?? this.toString();
+    return this.toString();
   }
 
   override set message(_message: string) {}
 
   override toString(): string {
-    if (this.printedMessage) {
-      return this.printedMessage;
-    }
     if (Array.isArray(this.details)) {
       return this.details.map(detail => detail.toString()).join('\n\n');
     }
     return this.name;
   }
 
-  withPrintedMessage(
-    source: string,
-    options: PrintErrorMessageOptions,
-  ): CompilerError {
-    this.printedMessage = this.printErrorMessage(source, options);
-    return this;
-  }
-
   printErrorMessage(source: string, options: PrintErrorMessageOptions): string {
     if (options.eslint && this.details.length === 1) {
       return this.details[0].printErrorMessage(source, options);

compiler/packages/babel-plugin-react-compiler/src/Entrypoint/Pipeline.ts

@@ -174,7 +174,7 @@ function runWithEnvironment(
     !env.config.disableMemoizationForDebugging &&
     !env.config.enableChangeDetectionForDebugging
   ) {
-    dropManualMemoization(hir).unwrap();
+    dropManualMemoization(hir);
     log({kind: 'hir', name: 'DropManualMemoization', value: hir});
   }
 

compiler/packages/babel-plugin-react-compiler/src/Entrypoint/Suppression.ts

@@ -8,8 +8,8 @@
 import {NodePath} from '@babel/core';
 import * as t from '@babel/types';
 import {
-  CompilerDiagnostic,
   CompilerError,
+  CompilerErrorDetail,
   CompilerSuggestionOperation,
   ErrorSeverity,
 } from '../CompilerError';
@@ -181,11 +181,12 @@ export function suppressionsToCompilerError(
           'Unhandled suppression source',
         );
     }
-    error.pushDiagnostic(
-      CompilerDiagnostic.create({
-        category: reason,
-        description: `React Compiler only works when your components follow all the rules of React, disabling them may result in unexpected or incorrect behavior. Found suppression \`${suppressionRange.disableComment.value.trim()}\``,
+    error.pushErrorDetail(
+      new CompilerErrorDetail({
+        reason: `${reason}. React Compiler only works when your components follow all the rules of React, disabling them may result in unexpected or incorrect behavior`,
+        description: suppressionRange.disableComment.value.trim(),
         severity: ErrorSeverity.InvalidReact,
+        loc: suppressionRange.disableComment.loc ?? null,
         suggestions: [
           {
             description: suggestion,
@@ -196,10 +197,6 @@ export function suppressionsToCompilerError(
             op: CompilerSuggestionOperation.Remove,
           },
         ],
-      }).withDetail({
-        kind: 'error',
-        loc: suppressionRange.disableComment.loc ?? null,
-        message: 'Found React rule suppression',
       }),
     );
   }

compiler/packages/babel-plugin-react-compiler/src/HIR/BuildHIR.ts

@@ -189,7 +189,6 @@ export function lower(
     const fallthrough = builder.reserve('block');
     const terminal: ReturnTerminal = {
       kind: 'return',
-      returnVariant: 'Implicit',
       loc: GeneratedSource,
       value: lowerExpressionToTemporary(builder, body),
       id: makeInstructionId(0),
@@ -220,7 +219,6 @@ export function lower(
   builder.terminate(
     {
       kind: 'return',
-      returnVariant: 'Void',
       loc: GeneratedSource,
       value: lowerValueToTemporary(builder, {
         kind: 'Primitive',
@@ -304,7 +302,6 @@ function lowerStatement(
       }
       const terminal: ReturnTerminal = {
         kind: 'return',
-        returnVariant: 'Explicit',
         loc: stmt.node.loc ?? GeneratedSource,
         value,
         id: makeInstructionId(0),

compiler/packages/babel-plugin-react-compiler/src/HIR/Environment.ts

@@ -631,17 +631,6 @@ export const EnvironmentConfigSchema = z.object({
    * ```
    */
   lowerContextAccess: ExternalFunctionSchema.nullable().default(null),
-
-  /**
-   * If enabled, will validate useMemos that don't return any values:
-   *
-   * Valid:
-   *   useMemo(() => foo, [foo]);
-   *   useMemo(() => { return foo }, [foo]);
-   * Invalid:
-   *   useMemo(() => { ... }, [...]);
-   */
-  validateNoVoidUseMemo: z.boolean().default(false),
 });
 
 export type EnvironmentConfig = z.infer<typeof EnvironmentConfigSchema>;

compiler/packages/babel-plugin-react-compiler/src/HIR/HIR.ts

@@ -446,20 +446,8 @@ export type ThrowTerminal = {
 };
 export type Case = {test: Place | null; block: BlockId};
 
-export type ReturnVariant = 'Void' | 'Implicit' | 'Explicit';
 export type ReturnTerminal = {
   kind: 'return';
-  /**
-   * Void:
-   *   () => { ... }
-   *   function() { ... }
-   * Implicit (ArrowFunctionExpression only):
-   *   () => foo
-   * Explicit:
-   *   () => { return ... }
-   *   function () { return ... }
-   */
-  returnVariant: ReturnVariant;
   loc: SourceLocation;
   value: Place;
   id: InstructionId;

compiler/packages/babel-plugin-react-compiler/src/HIR/ObjectShape.ts

@@ -1211,8 +1211,6 @@ addObject(BUILTIN_SHAPES, BuiltInRefValueId, [
   ['*', {kind: 'Object', shapeId: BuiltInRefValueId}],
 ]);
 
-addObject(BUILTIN_SHAPES, ReanimatedSharedValueId, []);
-
 addFunction(
   BUILTIN_SHAPES,
   [],

compiler/packages/babel-plugin-react-compiler/src/HIR/PrintHIR.ts

@@ -215,7 +215,7 @@ export function printTerminal(terminal: Terminal): Array<string> | string {
       break;
     }
     case 'return': {
-      value = `[${terminal.id}] Return ${terminal.returnVariant}${
+      value = `[${terminal.id}] Return${
         terminal.value != null ? ' ' + printPlace(terminal.value) : ''
       }`;
       if (terminal.effects != null) {
@@ -943,10 +943,7 @@ export function printAliasingEffect(effect: AliasingEffect): string {
       return `Assign ${printPlaceForAliasEffect(effect.into)} = ${printPlaceForAliasEffect(effect.from)}`;
     }
     case 'Alias': {
-      return `Alias ${printPlaceForAliasEffect(effect.into)} <- ${printPlaceForAliasEffect(effect.from)}`;
-    }
-    case 'MaybeAlias': {
-      return `MaybeAlias ${printPlaceForAliasEffect(effect.into)} <- ${printPlaceForAliasEffect(effect.from)}`;
+      return `Alias ${printPlaceForAliasEffect(effect.into)} = ${printPlaceForAliasEffect(effect.from)}`;
     }
     case 'Capture': {
       return `Capture ${printPlaceForAliasEffect(effect.into)} <- ${printPlaceForAliasEffect(effect.from)}`;

compiler/packages/babel-plugin-react-compiler/src/HIR/visitors.ts

@@ -777,7 +777,6 @@ export function mapTerminalSuccessors(
     case 'return': {
       return {
         kind: 'return',
-        returnVariant: terminal.returnVariant,
         loc: terminal.loc,
         value: terminal.value,
         id: makeInstructionId(0),

compiler/packages/babel-plugin-react-compiler/src/Inference/AliasingEffects.ts

@@ -90,23 +90,6 @@ export type AliasingEffect =
    * c could be mutating a.
    */
   | {kind: 'Alias'; from: Place; into: Place}
-
-  /**
-   * Indicates the potential for information flow from `from` to `into`. This is used for a specific
-   * case: functions with unknown signatures. If the compiler sees a call such as `foo(x)`, it has to
-   * consider several possibilities (which may depend on the arguments):
-   * - foo(x) returns a new mutable value that does not capture any information from x.
-   * - foo(x) returns a new mutable value that *does* capture information from x.
-   * - foo(x) returns x itself, ie foo is the identity function
-   *
-   * The same is true of functions that take multiple arguments: `cond(a, b, c)` could conditionally
-   * return b or c depending on the value of a.
-   *
-   * To represent this case, MaybeAlias represents the fact that an aliasing relationship could exist.
-   * Any mutations that flow through this relationship automatically become conditional.
-   */
-  | {kind: 'MaybeAlias'; from: Place; into: Place}
-
   /**
    * Records direct assignment: `into = from`.
    */
@@ -200,8 +183,7 @@ export function hashEffect(effect: AliasingEffect): string {
     case 'ImmutableCapture':
     case 'Assign':
     case 'Alias':
-    case 'Capture':
-    case 'MaybeAlias': {
+    case 'Capture': {
       return [
         effect.kind,
         effect.from.identifier.id,

compiler/packages/babel-plugin-react-compiler/src/Inference/AnalyseFunctions.ts

@@ -85,8 +85,7 @@ function lowerWithMutationAliasing(fn: HIRFunction): void {
       case 'Assign':
       case 'Alias':
       case 'Capture':
-      case 'CreateFrom':
-      case 'MaybeAlias': {
+      case 'CreateFrom': {
         capturedOrMutated.add(effect.from.identifier.id);
         break;
       }

compiler/packages/babel-plugin-react-compiler/src/Inference/DropManualMemoization.ts

@@ -5,12 +5,7 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-import {
-  CompilerDiagnostic,
-  CompilerError,
-  ErrorSeverity,
-  SourceLocation,
-} from '..';
+import {CompilerError, SourceLocation} from '..';
 import {
   CallExpression,
   Effect,
@@ -35,7 +30,6 @@ import {
   makeInstructionId,
 } from '../HIR';
 import {createTemporaryPlace, markInstructionIds} from '../HIR/HIRBuilder';
-import {Result} from '../Utils/Result';
 
 type ManualMemoCallee = {
   kind: 'useMemo' | 'useCallback';
@@ -289,43 +283,26 @@ function extractManualMemoizationArgs(
   instr: TInstruction<CallExpression> | TInstruction<MethodCall>,
   kind: 'useCallback' | 'useMemo',
   sidemap: IdentifierSidemap,
-  errors: CompilerError,
 ): {
-  fnPlace: Place | null;
+  fnPlace: Place;
   depsList: Array<ManualMemoDependency> | null;
 } {
   const [fnPlace, depsListPlace] = instr.value.args as Array<
     Place | SpreadPattern | undefined
   >;
   if (fnPlace == null) {
-    errors.pushDiagnostic(
-      CompilerDiagnostic.create({
-        severity: ErrorSeverity.InvalidReact,
-        category: `Expected a callback function to be passed to ${kind}`,
-        description: `Expected a callback function to be passed to ${kind}`,
-        suggestions: null,
-      }).withDetail({
-        kind: 'error',
-        loc: instr.value.loc,
-        message: `Expected a callback function to be passed to ${kind}`,
-      }),
-    );
-    return {fnPlace: null, depsList: null};
+    CompilerError.throwInvalidReact({
+      reason: `Expected a callback function to be passed to ${kind}`,
+      loc: instr.value.loc,
+      suggestions: null,
+    });
   }
   if (fnPlace.kind === 'Spread' || depsListPlace?.kind === 'Spread') {
-    errors.pushDiagnostic(
-      CompilerDiagnostic.create({
-        severity: ErrorSeverity.InvalidReact,
-        category: `Unexpected spread argument to ${kind}`,
-        description: `Unexpected spread argument to ${kind}`,
-        suggestions: null,
-      }).withDetail({
-        kind: 'error',
-        loc: instr.value.loc,
-        message: `Unexpected spread argument to ${kind}`,
-      }),
-    );
-    return {fnPlace: null, depsList: null};
+    CompilerError.throwInvalidReact({
+      reason: `Unexpected spread argument to ${kind}`,
+      loc: instr.value.loc,
+      suggestions: null,
+    });
   }
   let depsList: Array<ManualMemoDependency> | null = null;
   if (depsListPlace != null) {
@@ -333,40 +310,23 @@ function extractManualMemoizationArgs(
       depsListPlace.identifier.id,
     );
     if (maybeDepsList == null) {
-      errors.pushDiagnostic(
-        CompilerDiagnostic.create({
-          severity: ErrorSeverity.InvalidReact,
-          category: `Expected the dependency list for ${kind} to be an array literal`,
-          description: `Expected the dependency list for ${kind} to be an array literal`,
-          suggestions: null,
-        }).withDetail({
-          kind: 'error',
-          loc: depsListPlace.loc,
-          message: `Expected the dependency list for ${kind} to be an array literal`,
-        }),
-      );
-      return {fnPlace, depsList: null};
+      CompilerError.throwInvalidReact({
+        reason: `Expected the dependency list for ${kind} to be an array literal`,
+        suggestions: null,
+        loc: depsListPlace.loc,
+      });
     }
-    depsList = [];
-    for (const dep of maybeDepsList) {
+    depsList = maybeDepsList.map(dep => {
       const maybeDep = sidemap.maybeDeps.get(dep.identifier.id);
       if (maybeDep == null) {
-        errors.pushDiagnostic(
-          CompilerDiagnostic.create({
-            severity: ErrorSeverity.InvalidReact,
-            category: `Expected the dependency list to be an array of simple expressions (e.g. \`x\`, \`x.y.z\`, \`x?.y?.z\`)`,
-            description: `Expected the dependency list to be an array of simple expressions (e.g. \`x\`, \`x.y.z\`, \`x?.y?.z\`)`,
-            suggestions: null,
-          }).withDetail({
-            kind: 'error',
-            loc: dep.loc,
-            message: `Expected the dependency list to be an array of simple expressions (e.g. \`x\`, \`x.y.z\`, \`x?.y?.z\`)`,
-          }),
-        );
-      } else {
-        depsList.push(maybeDep);
+        CompilerError.throwInvalidReact({
+          reason: `Expected the dependency list to be an array of simple expressions (e.g. \`x\`, \`x.y.z\`, \`x?.y?.z\`)`,
+          suggestions: null,
+          loc: dep.loc,
+        });
       }
-    }
+      return maybeDep;
+    });
   }
   return {
     fnPlace,
@@ -381,14 +341,8 @@ function extractManualMemoizationArgs(
  * rely on type inference to find useMemo/useCallback invocations, and instead does basic tracking
  * of globals and property loads to find both direct calls as well as usage via the React namespace,
  * eg `React.useMemo()`.
- *
- * This pass also validates that useMemo callbacks return a value (not void), ensuring that useMemo
- * is only used for memoizing values and not for running arbitrary side effects.
  */
-export function dropManualMemoization(
-  func: HIRFunction,
-): Result<void, CompilerError> {
-  const errors = new CompilerError();
+export function dropManualMemoization(func: HIRFunction): void {
   const isValidationEnabled =
     func.env.config.validatePreserveExistingMemoizationGuarantees ||
     func.env.config.validateNoSetStateInRender ||
@@ -435,47 +389,7 @@ export function dropManualMemoization(
             instr as TInstruction<CallExpression> | TInstruction<MethodCall>,
             manualMemo.kind,
             sidemap,
-            errors,
           );
-
-          if (fnPlace == null) {
-            continue;
-          }
-
-          /**
-           * Bailout on void return useMemos. This is an anti-pattern where code might be using
-           * useMemo like useEffect: running arbirtary side-effects synced to changes in specific
-           * values.
-           */
-          if (
-            func.env.config.validateNoVoidUseMemo &&
-            manualMemo.kind === 'useMemo'
-          ) {
-            const funcToCheck = sidemap.functions.get(
-              fnPlace.identifier.id,
-            )?.value;
-            if (funcToCheck !== undefined && funcToCheck.loweredFunc.func) {
-              if (!hasNonVoidReturn(funcToCheck.loweredFunc.func)) {
-                errors.pushDiagnostic(
-                  CompilerDiagnostic.create({
-                    severity: ErrorSeverity.InvalidReact,
-                    category: 'useMemo() callbacks must return a value',
-                    description: `This ${
-                      manualMemo.loadInstr.value.kind === 'PropertyLoad'
-                        ? 'React.useMemo'
-                        : 'useMemo'
-                    } callback doesn't return a value. useMemo is for computing and caching values, not for arbitrary side effects.`,
-                    suggestions: null,
-                  }).withDetail({
-                    kind: 'error',
-                    loc: instr.value.loc,
-                    message: 'useMemo() callbacks must return a value',
-                  }),
-                );
-              }
-            }
-          }
-
           instr.value = getManualMemoizationReplacement(
             fnPlace,
             instr.value.loc,
@@ -496,19 +410,11 @@ export function dropManualMemoization(
              * is rare and likely sketchy.
              */
             if (!sidemap.functions.has(fnPlace.identifier.id)) {
-              errors.pushDiagnostic(
-                CompilerDiagnostic.create({
-                  severity: ErrorSeverity.InvalidReact,
-                  category: `Expected the first argument to be an inline function expression`,
-                  description: `Expected the first argument to be an inline function expression`,
-                  suggestions: [],
-                }).withDetail({
-                  kind: 'error',
-                  loc: fnPlace.loc,
-                  message: `Expected the first argument to be an inline function expression`,
-                }),
-              );
-              continue;
+              CompilerError.throwInvalidReact({
+                reason: `Expected the first argument to be an inline function expression`,
+                suggestions: [],
+                loc: fnPlace.loc,
+              });
             }
             const memoDecl: Place =
               manualMemo.kind === 'useMemo'
@@ -580,8 +486,6 @@ export function dropManualMemoization(
       markInstructionIds(func.body);
     }
   }
-
-  return errors.asResult();
 }
 
 function findOptionalPlaces(fn: HIRFunction): Set<IdentifierId> {
@@ -626,17 +530,3 @@ function findOptionalPlaces(fn: HIRFunction): Set<IdentifierId> {
   }
   return optionals;
 }
-
-function hasNonVoidReturn(func: HIRFunction): boolean {
-  for (const [, block] of func.body.blocks) {
-    if (block.terminal.kind === 'return') {
-      if (
-        block.terminal.returnVariant === 'Explicit' ||
-        block.terminal.returnVariant === 'Implicit'
-      ) {
-        return true;
-      }
-    }
-  }
-  return false;
-}

compiler/packages/babel-plugin-react-compiler/src/Inference/InferMutationAliasingEffects.ts

@@ -691,7 +691,6 @@ function applyEffect(
       }
       break;
     }
-    case 'MaybeAlias':
     case 'Alias':
     case 'Capture': {
       CompilerError.invariant(
@@ -956,7 +955,7 @@ function applyEffect(
             context,
             state,
             // OK: recording information flow
-            {kind: 'MaybeAlias', from: operand, into: effect.into},
+            {kind: 'Alias', from: operand, into: effect.into},
             initialized,
             effects,
           );
@@ -1324,7 +1323,7 @@ class InferenceState {
             return 'mutate-global';
           }
           case ValueKind.MaybeFrozen: {
-            return 'mutate-frozen';
+            return 'none';
           }
           default: {
             assertExhaustive(kind, `Unexpected kind ${kind}`);
@@ -2377,7 +2376,6 @@ function computeEffectsForSignature(
   // Apply substitutions
   for (const effect of signature.effects) {
     switch (effect.kind) {
-      case 'MaybeAlias':
       case 'Assign':
       case 'ImmutableCapture':
       case 'Alias':

compiler/packages/babel-plugin-react-compiler/src/Inference/InferMutationAliasingRanges.ts

@@ -160,8 +160,6 @@ export function inferMutationAliasingRanges(
           state.assign(index++, effect.from, effect.into);
         } else if (effect.kind === 'Alias') {
           state.assign(index++, effect.from, effect.into);
-        } else if (effect.kind === 'MaybeAlias') {
-          state.maybeAlias(index++, effect.from, effect.into);
         } else if (effect.kind === 'Capture') {
           state.capture(index++, effect.from, effect.into);
         } else if (
@@ -249,7 +247,6 @@ export function inferMutationAliasingRanges(
   }
   for (const param of [...fn.context, ...fn.params]) {
     const place = param.kind === 'Identifier' ? param : param.place;
-
     const node = state.nodes.get(place.identifier);
     if (node == null) {
       continue;
@@ -349,8 +346,7 @@ export function inferMutationAliasingRanges(
           case 'Assign':
           case 'Alias':
           case 'Capture':
-          case 'CreateFrom':
-          case 'MaybeAlias': {
+          case 'CreateFrom': {
             const isMutatedOrReassigned =
               effect.into.identifier.mutableRange.end > instr.id;
             if (isMutatedOrReassigned) {
@@ -571,12 +567,7 @@ type Node = {
   createdFrom: Map<Identifier, number>;
   captures: Map<Identifier, number>;
   aliases: Map<Identifier, number>;
-  maybeAliases: Map<Identifier, number>;
-  edges: Array<{
-    index: number;
-    node: Identifier;
-    kind: 'capture' | 'alias' | 'maybeAlias';
-  }>;
+  edges: Array<{index: number; node: Identifier; kind: 'capture' | 'alias'}>;
   transitive: {kind: MutationKind; loc: SourceLocation} | null;
   local: {kind: MutationKind; loc: SourceLocation} | null;
   lastMutated: number;
@@ -594,7 +585,6 @@ class AliasingState {
       createdFrom: new Map(),
       captures: new Map(),
       aliases: new Map(),
-      maybeAliases: new Map(),
       edges: [],
       transitive: null,
       local: null,
@@ -640,18 +630,6 @@ class AliasingState {
     }
   }
 
-  maybeAlias(index: number, from: Place, into: Place): void {
-    const fromNode = this.nodes.get(from.identifier);
-    const toNode = this.nodes.get(into.identifier);
-    if (fromNode == null || toNode == null) {
-      return;
-    }
-    fromNode.edges.push({index, node: into.identifier, kind: 'maybeAlias'});
-    if (!toNode.maybeAliases.has(from.identifier)) {
-      toNode.maybeAliases.set(from.identifier, index);
-    }
-  }
-
   render(index: number, start: Identifier, errors: CompilerError): void {
     const seen = new Set<Identifier>();
     const queue: Array<Identifier> = [start];
@@ -695,24 +673,22 @@ class AliasingState {
     // Null is used for simulated mutations
     end: InstructionId | null,
     transitive: boolean,
-    startKind: MutationKind,
+    kind: MutationKind,
     loc: SourceLocation,
     errors: CompilerError,
   ): void {
-    const seen = new Map<Identifier, MutationKind>();
+    const seen = new Set<Identifier>();
     const queue: Array<{
       place: Identifier;
       transitive: boolean;
       direction: 'backwards' | 'forwards';
-      kind: MutationKind;
-    }> = [{place: start, transitive, direction: 'backwards', kind: startKind}];
+    }> = [{place: start, transitive, direction: 'backwards'}];
     while (queue.length !== 0) {
-      const {place: current, transitive, direction, kind} = queue.pop()!;
-      const previousKind = seen.get(current);
-      if (previousKind != null && previousKind >= kind) {
+      const {place: current, transitive, direction} = queue.pop()!;
+      if (seen.has(current)) {
         continue;
       }
-      seen.set(current, kind);
+      seen.add(current);
       const node = this.nodes.get(current);
       if (node == null) {
         continue;
@@ -748,18 +724,13 @@ class AliasingState {
         if (edge.index >= index) {
           break;
         }
-        queue.push({place: edge.node, transitive, direction: 'forwards', kind});
+        queue.push({place: edge.node, transitive, direction: 'forwards'});
       }
       for (const [alias, when] of node.createdFrom) {
         if (when >= index) {
           continue;
         }
-        queue.push({
-          place: alias,
-          transitive: true,
-          direction: 'backwards',
-          kind,
-        });
+        queue.push({place: alias, transitive: true, direction: 'backwards'});
       }
       if (direction === 'backwards' || node.value.kind !== 'Phi') {
         /**
@@ -776,25 +747,7 @@ class AliasingState {
           if (when >= index) {
             continue;
           }
-          queue.push({place: alias, transitive, direction: 'backwards', kind});
-        }
-        /**
-         * MaybeAlias indicates potential data flow from unknown function calls,
-         * so we downgrade mutations through these aliases to consider them
-         * conditional. This means we'll consider them for mutation *range*
-         * purposes but not report validation errors for mutations, since
-         * we aren't sure that the `from` value could actually be aliased.
-         */
-        for (const [alias, when] of node.maybeAliases) {
-          if (when >= index) {
-            continue;
-          }
-          queue.push({
-            place: alias,
-            transitive,
-            direction: 'backwards',
-            kind: MutationKind.Conditional,
-          });
+          queue.push({place: alias, transitive, direction: 'backwards'});
         }
       }
       /**
@@ -805,12 +758,7 @@ class AliasingState {
           if (when >= index) {
             continue;
           }
-          queue.push({
-            place: capture,
-            transitive,
-            direction: 'backwards',
-            kind,
-          });
+          queue.push({place: capture, transitive, direction: 'backwards'});
         }
       }
     }

compiler/packages/babel-plugin-react-compiler/src/Inference/InferReactivePlaces.ts

@@ -21,6 +21,7 @@ import {
   isStableType,
   isStableTypeContainer,
   isUseOperator,
+  isUseRefType,
 } from '../HIR';
 import {PostDominator} from '../HIR/Dominator';
 import {
@@ -69,6 +70,13 @@ class StableSidemap {
               isStable: false,
             });
           }
+        } else if (
+          this.env.config.enableTreatRefLikeIdentifiersAsRefs &&
+          isUseRefType(lvalue.identifier)
+        ) {
+          this.map.set(lvalue.identifier.id, {
+            isStable: true,
+          });
         }
         break;
       }

compiler/packages/babel-plugin-react-compiler/src/Inference/MUTABILITY_ALIASING_MODEL.md

@@ -153,10 +153,6 @@ This is somewhat the inverse of `Capture`. The `CreateFrom` effect describes tha
 
 Describes immutable data flow from one value to another. This is not currently used for anything, but is intended to eventually power a more sophisticated escape analysis.
 
-### MaybeAlias
-
-Describes potential data flow that the compiler knows may occur behind a function call, but cannot be sure about. For example, `foo(x)` _may_ be the identity function and return `x`, or `cond(a, b, c)` may conditionally return `b` or `c` depending on the value of `a`, but those functions could just as easily return new mutable values and not capture any information from their arguments. MaybeAlias represents that we have to consider the potential for data flow when deciding mutable ranges, but should be conservative about reporting errors. For example, `foo(someFrozenValue).property = true` should not error since we don't know for certain that foo returns its input.
-
 ### State-Changing Effects
 
 The following effects describe state changes to specific values, not data flow. In many cases, JavaScript semantics will involve a combination of both data-flow effects *and* state-change effects. For example, `object.property = value` has data flow (`Capture object <- value`) and mutation (`Mutate object`).
@@ -351,17 +347,6 @@ a.b = b; // capture
 mutate(a); // can transitively mutate b
 ```
 
-### MaybeAlias makes mutation conditional
-
-Because we don't know for certain that the aliasing occurs, we consider the mutation conditional against the source.
-
-```
-MaybeAlias a <- b
-Mutate a
-=>
-MutateConditional b
-```
-
 ### Freeze Does Not Freeze the Value
 
 Freeze does not freeze the value itself:

compiler/packages/babel-plugin-react-compiler/src/Optimization/LowerContextAccess.ts

@@ -237,7 +237,6 @@ function emitSelectorFn(env: Environment, keys: Array<string>): Instruction {
     terminal: {
       id: makeInstructionId(0),
       kind: 'return',
-      returnVariant: 'Explicit',
       loc: GeneratedSource,
       value: arrayInstr.lvalue,
       effects: null,

compiler/packages/babel-plugin-react-compiler/src/Optimization/OutlineJsx.ts

@@ -352,7 +352,6 @@ function emitOutlinedFn(
     terminal: {
       id: makeInstructionId(0),
       kind: 'return',
-      returnVariant: 'Explicit',
       loc: GeneratedSource,
       value: instructions.at(-1)!.lvalue,
       effects: null,

compiler/packages/babel-plugin-react-compiler/src/TypeInference/InferTypes.ts

@@ -14,7 +14,6 @@ import {
   Identifier,
   IdentifierId,
   Instruction,
-  InstructionKind,
   makePropertyLiteral,
   makeType,
   PropType,
@@ -195,29 +194,12 @@ function* generateInstructionTypes(
       break;
     }
 
-    // We intentionally do not infer types for most context variables
+    // We intentionally do not infer types for context variables
     case 'DeclareContext':
+    case 'StoreContext':
     case 'LoadContext': {
       break;
     }
-    case 'StoreContext': {
-      /**
-       * The caveat is StoreContext const, where we know the value is
-       * assigned once such that everywhere the value is accessed, it
-       * must have the same type from the rvalue.
-       *
-       * A concrete example where this is useful is `const ref = useRef()`
-       * where the ref is referenced before its declaration in a function
-       * expression, causing it to be converted to a const context variable.
-       */
-      if (value.lvalue.kind === InstructionKind.Const) {
-        yield equation(
-          value.lvalue.place.identifier.type,
-          value.value.identifier.type,
-        );
-      }
-      break;
-    }
 
     case 'StoreLocal': {
       if (env.config.enableUseTypeAnnotations) {
@@ -466,36 +448,7 @@ function* generateInstructionTypes(
       yield equation(left, returnType);
       break;
     }
-    case 'PropertyStore': {
-      /**
-       * Infer types based on assignments to known object properties
-       * This is important for refs, where assignment to `<maybeRef>.current`
-       * can help us infer that an object itself is a ref
-       */
-      yield equation(
-        /**
-         * Our property type declarations are best-effort and we haven't tested
-         * using them to drive inference of rvalues from lvalues. We want to emit
-         * a Property type in order to infer refs from `.current` accesses, but
-         * stay conservative by not otherwise inferring anything about rvalues.
-         * So we use a dummy type here.
-         *
-         * TODO: consider using the rvalue type here
-         */
-        makeType(),
-        // unify() only handles properties in the second position
-        {
-          kind: 'Property',
-          objectType: value.object.identifier.type,
-          objectName: getName(names, value.object.identifier.id),
-          propertyName: {
-            kind: 'literal',
-            value: value.property,
-          },
-        },
-      );
-      break;
-    }
+    case 'PropertyStore':
     case 'DeclareLocal':
     case 'RegExpLiteral':
     case 'MetaProperty':

compiler/packages/babel-plugin-react-compiler/src/Utils/TestUtils.ts

@@ -113,13 +113,8 @@ function* splitPragma(
  */
 function parseConfigPragmaEnvironmentForTest(
   pragma: string,
-  defaultConfig: PartialEnvironmentConfig,
 ): EnvironmentConfig {
-  // throw early if the defaults are invalid
-  EnvironmentConfigSchema.parse(defaultConfig);
-
-  const maybeConfig: Partial<Record<keyof EnvironmentConfig, unknown>> =
-    defaultConfig;
+  const maybeConfig: Partial<Record<keyof EnvironmentConfig, unknown>> = {};
 
   for (const {key, value: val} of splitPragma(pragma)) {
     if (!hasOwnProperty(EnvironmentConfigSchema.shape, key)) {
@@ -179,13 +174,9 @@ export function parseConfigPragmaForTests(
   pragma: string,
   defaults: {
     compilationMode: CompilationMode;
-    environment?: PartialEnvironmentConfig;
   },
 ): PluginOptions {
-  const environment = parseConfigPragmaEnvironmentForTest(
-    pragma,
-    defaults.environment ?? {},
-  );
+  const environment = parseConfigPragmaEnvironmentForTest(pragma);
   const options: Record<keyof PluginOptions, unknown> = {
     ...defaultOptions,
     panicThreshold: 'all_errors',

compiler/packages/babel-plugin-react-compiler/src/Validation/ValidateNoRefAccessInRender.ts

@@ -5,11 +5,7 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-import {
-  CompilerDiagnostic,
-  CompilerError,
-  ErrorSeverity,
-} from '../CompilerError';
+import {CompilerError, ErrorSeverity} from '../CompilerError';
 import {
   BlockId,
   HIRFunction,
@@ -389,40 +385,28 @@ function validateNoRefAccessInRenderImpl(
             const hookKind = getHookKindForType(fn.env, callee.identifier.type);
             let returnType: RefAccessType = {kind: 'None'};
             const fnType = env.get(callee.identifier.id);
-            let didError = false;
             if (fnType?.kind === 'Structure' && fnType.fn !== null) {
               returnType = fnType.fn.returnType;
               if (fnType.fn.readRefEffect) {
-                didError = true;
-                errors.pushDiagnostic(
-                  CompilerDiagnostic.create({
-                    severity: ErrorSeverity.InvalidReact,
-                    category: 'Cannot access refs during render',
-                    description: ERROR_DESCRIPTION,
-                  }).withDetail({
-                    kind: 'error',
-                    loc: callee.loc,
-                    message: `This function accesses a ref value`,
-                  }),
-                );
+                errors.push({
+                  severity: ErrorSeverity.InvalidReact,
+                  reason:
+                    'This function accesses a ref value (the `current` property), which may not be accessed during render. (https://react.dev/reference/react/useRef)',
+                  loc: callee.loc,
+                  description:
+                    callee.identifier.name !== null &&
+                    callee.identifier.name.kind === 'named'
+                      ? `Function \`${callee.identifier.name.value}\` accesses a ref`
+                      : null,
+                  suggestions: null,
+                });
               }
             }
-            if (!didError) {
-              /*
-               * If we already reported an error on this instruction, don't report
-               * duplicate errors
-               */
-              for (const operand of eachInstructionValueOperand(instr.value)) {
-                if (hookKind != null) {
-                  validateNoDirectRefValueAccess(errors, operand, env);
-                } else {
-                  validateNoRefPassedToFunction(
-                    errors,
-                    env,
-                    operand,
-                    operand.loc,
-                  );
-                }
+            for (const operand of eachInstructionValueOperand(instr.value)) {
+              if (hookKind != null) {
+                validateNoDirectRefValueAccess(errors, operand, env);
+              } else {
+                validateNoRefAccess(errors, env, operand, operand.loc);
               }
             }
             env.set(instr.lvalue.identifier.id, returnType);
@@ -465,7 +449,7 @@ function validateNoRefAccessInRenderImpl(
             ) {
               safeBlocks.delete(block.id);
             } else {
-              validateNoRefUpdate(errors, env, instr.value.object, instr.loc);
+              validateNoRefAccess(errors, env, instr.value.object, instr.loc);
             }
             for (const operand of eachInstructionValueOperand(instr.value)) {
               if (operand === instr.value.object) {
@@ -599,17 +583,18 @@ function destructure(
 
 function guardCheck(errors: CompilerError, operand: Place, env: Env): void {
   if (env.get(operand.identifier.id)?.kind === 'Guard') {
-    errors.pushDiagnostic(
-      CompilerDiagnostic.create({
-        severity: ErrorSeverity.InvalidReact,
-        category: 'Cannot access refs during render',
-        description: ERROR_DESCRIPTION,
-      }).withDetail({
-        kind: 'error',
-        loc: operand.loc,
-        message: `Cannot access ref value during render`,
-      }),
-    );
+    errors.push({
+      severity: ErrorSeverity.InvalidReact,
+      reason:
+        'Ref values (the `current` property) may not be accessed during render. (https://react.dev/reference/react/useRef)',
+      loc: operand.loc,
+      description:
+        operand.identifier.name !== null &&
+        operand.identifier.name.kind === 'named'
+          ? `Cannot access ref value \`${operand.identifier.name.value}\``
+          : null,
+      suggestions: null,
+    });
   }
 }
 
@@ -623,21 +608,22 @@ function validateNoRefValueAccess(
     type?.kind === 'RefValue' ||
     (type?.kind === 'Structure' && type.fn?.readRefEffect)
   ) {
-    errors.pushDiagnostic(
-      CompilerDiagnostic.create({
-        severity: ErrorSeverity.InvalidReact,
-        category: 'Cannot access refs during render',
-        description: ERROR_DESCRIPTION,
-      }).withDetail({
-        kind: 'error',
-        loc: (type.kind === 'RefValue' && type.loc) || operand.loc,
-        message: `Cannot access ref value during render`,
-      }),
-    );
+    errors.push({
+      severity: ErrorSeverity.InvalidReact,
+      reason:
+        'Ref values (the `current` property) may not be accessed during render. (https://react.dev/reference/react/useRef)',
+      loc: (type.kind === 'RefValue' && type.loc) || operand.loc,
+      description:
+        operand.identifier.name !== null &&
+        operand.identifier.name.kind === 'named'
+          ? `Cannot access ref value \`${operand.identifier.name.value}\``
+          : null,
+      suggestions: null,
+    });
   }
 }
 
-function validateNoRefPassedToFunction(
+function validateNoRefAccess(
   errors: CompilerError,
   env: Env,
   operand: Place,
@@ -649,43 +635,18 @@ function validateNoRefPassedToFunction(
     type?.kind === 'RefValue' ||
     (type?.kind === 'Structure' && type.fn?.readRefEffect)
   ) {
-    errors.pushDiagnostic(
-      CompilerDiagnostic.create({
-        severity: ErrorSeverity.InvalidReact,
-        category: 'Cannot access refs during render',
-        description: ERROR_DESCRIPTION,
-      }).withDetail({
-        kind: 'error',
-        loc: (type.kind === 'RefValue' && type.loc) || loc,
-        message: `Passing a ref to a function may read its value during render`,
-      }),
-    );
-  }
-}
-
-function validateNoRefUpdate(
-  errors: CompilerError,
-  env: Env,
-  operand: Place,
-  loc: SourceLocation,
-): void {
-  const type = destructure(env.get(operand.identifier.id));
-  if (
-    type?.kind === 'Ref' ||
-    type?.kind === 'RefValue' ||
-    (type?.kind === 'Structure' && type.fn?.readRefEffect)
-  ) {
-    errors.pushDiagnostic(
-      CompilerDiagnostic.create({
-        severity: ErrorSeverity.InvalidReact,
-        category: 'Cannot access refs during render',
-        description: ERROR_DESCRIPTION,
-      }).withDetail({
-        kind: 'error',
-        loc: (type.kind === 'RefValue' && type.loc) || loc,
-        message: `Cannot update ref during render`,
-      }),
-    );
+    errors.push({
+      severity: ErrorSeverity.InvalidReact,
+      reason:
+        'Ref values (the `current` property) may not be accessed during render. (https://react.dev/reference/react/useRef)',
+      loc: (type.kind === 'RefValue' && type.loc) || loc,
+      description:
+        operand.identifier.name !== null &&
+        operand.identifier.name.kind === 'named'
+          ? `Cannot access ref value \`${operand.identifier.name.value}\``
+          : null,
+      suggestions: null,
+    });
   }
 }
 
@@ -696,22 +657,17 @@ function validateNoDirectRefValueAccess(
 ): void {
   const type = destructure(env.get(operand.identifier.id));
   if (type?.kind === 'RefValue') {
-    errors.pushDiagnostic(
-      CompilerDiagnostic.create({
-        severity: ErrorSeverity.InvalidReact,
-        category: 'Cannot access refs during render',
-        description: ERROR_DESCRIPTION,
-      }).withDetail({
-        kind: 'error',
-        loc: type.loc ?? operand.loc,
-        message: `Cannot access ref value during render`,
-      }),
-    );
+    errors.push({
+      severity: ErrorSeverity.InvalidReact,
+      reason:
+        'Ref values (the `current` property) may not be accessed during render. (https://react.dev/reference/react/useRef)',
+      loc: type.loc ?? operand.loc,
+      description:
+        operand.identifier.name !== null &&
+        operand.identifier.name.kind === 'named'
+          ? `Cannot access ref value \`${operand.identifier.name.value}\``
+          : null,
+      suggestions: null,
+    });
   }
 }
-
-const ERROR_DESCRIPTION =
-  'React refs are values that are not needed for rendering. Refs should only be accessed ' +
-  'outside of render, such as in event handlers or effects. ' +
-  'Accessing a ref value (the `current` property) during render can cause your component ' +
-  'not to update as expected (https://react.dev/reference/react/useRef)';

compiler/packages/babel-plugin-react-compiler/src/Validation/ValidateNoSetStateInEffects.ts

@@ -97,21 +97,16 @@ export function validateNoSetStateInEffects(
                 errors.pushDiagnostic(
                   CompilerDiagnostic.create({
                     category:
-                      'Calling setState synchronously within an effect can trigger cascading renders',
+                      'Calling setState within an effect can trigger cascading renders',
                     description:
-                      'Effects are intended to synchronize state between React and external systems such as manually updating the DOM, state management libraries, or other platform APIs. ' +
-                      'In general, the body of an effect should do one or both of the following:\n' +
-                      '* Update external systems with the latest state from React.\n' +
-                      '* Subscribe for updates from some external system, calling setState in a callback function when external state changes.\n\n' +
-                      'Calling setState synchronously within an effect body causes cascading renders that can hurt performance, and is not recommended. ' +
-                      '(https://react.dev/learn/you-might-not-need-an-effect)',
+                      'Calling setState directly within a useEffect causes cascading renders that can hurt performance, and is not recommended. Consider alternatives to useEffect. (https://react.dev/learn/you-might-not-need-an-effect)',
                     severity: ErrorSeverity.InvalidReact,
                     suggestions: null,
                   }).withDetail({
                     kind: 'error',
                     loc: setState.loc,
                     message:
-                      'Avoid calling setState() directly within an effect',
+                      'Avoid calling setState() in the top-level of an effect',
                   }),
                 );
               }

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.bailout-on-flow-suppression.expect.md

@@ -18,15 +18,15 @@ function Foo(props) {
 ```
 Found 1 error:
 
-Error: React Compiler has skipped optimizing this component because one or more React rule violations were reported by Flow
+Error: React Compiler has skipped optimizing this component because one or more React rule violations were reported by Flow. React Compiler only works when your components follow all the rules of React, disabling them may result in unexpected or incorrect behavior
 
-React Compiler only works when your components follow all the rules of React, disabling them may result in unexpected or incorrect behavior. Found suppression `$FlowFixMe[react-rule-hook]`
+$FlowFixMe[react-rule-hook].
 
 error.bailout-on-flow-suppression.ts:4:2
   2 |
   3 | function Foo(props) {
 > 4 |   // $FlowFixMe[react-rule-hook]
-    |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Found React rule suppression
+    |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ React Compiler has skipped optimizing this component because one or more React rule violations were reported by Flow. React Compiler only works when your components follow all the rules of React, disabling them may result in unexpected or incorrect behavior
   5 |   useX();
   6 |   return null;
   7 | }

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.bailout-on-suppression-of-custom-rule.expect.md

@@ -21,28 +21,28 @@ function lowercasecomponent() {
 ```
 Found 2 errors:
 
-Error: React Compiler has skipped optimizing this component because one or more React ESLint rules were disabled
+Error: React Compiler has skipped optimizing this component because one or more React ESLint rules were disabled. React Compiler only works when your components follow all the rules of React, disabling them may result in unexpected or incorrect behavior
 
-React Compiler only works when your components follow all the rules of React, disabling them may result in unexpected or incorrect behavior. Found suppression `eslint-disable my-app/react-rule`
+eslint-disable my-app/react-rule.
 
 error.bailout-on-suppression-of-custom-rule.ts:3:0
   1 | // @eslintSuppressionRules:["my-app","react-rule"]
   2 |
 > 3 | /* eslint-disable my-app/react-rule */
-    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Found React rule suppression
+    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ React Compiler has skipped optimizing this component because one or more React ESLint rules were disabled. React Compiler only works when your components follow all the rules of React, disabling them may result in unexpected or incorrect behavior
   4 | function lowercasecomponent() {
   5 |   'use forget';
   6 |   const x = [];
 
-Error: React Compiler has skipped optimizing this component because one or more React ESLint rules were disabled
+Error: React Compiler has skipped optimizing this component because one or more React ESLint rules were disabled. React Compiler only works when your components follow all the rules of React, disabling them may result in unexpected or incorrect behavior
 
-React Compiler only works when your components follow all the rules of React, disabling them may result in unexpected or incorrect behavior. Found suppression `eslint-disable-next-line my-app/react-rule`
+eslint-disable-next-line my-app/react-rule.
 
 error.bailout-on-suppression-of-custom-rule.ts:7:2
    5 |   'use forget';
    6 |   const x = [];
 >  7 |   // eslint-disable-next-line my-app/react-rule
-     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Found React rule suppression
+     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ React Compiler has skipped optimizing this component because one or more React ESLint rules were disabled. React Compiler only works when your components follow all the rules of React, disabling them may result in unexpected or incorrect behavior
    8 |   return <div>{x}</div>;
    9 | }
   10 | /* eslint-enable my-app/react-rule */

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.capture-ref-for-mutation.expect.md

@@ -32,30 +32,48 @@ export const FIXTURE_ENTRYPOINT = {
 ## Error
 
 ```
-Found 2 errors:
+Found 4 errors:
 
-Error: Cannot access refs during render
-
-React refs are values that are not needed for rendering. Refs should only be accessed outside of render, such as in event handlers or effects. Accessing a ref value (the `current` property) during render can cause your component not to update as expected (https://react.dev/reference/react/useRef)
+Error: This function accesses a ref value (the `current` property), which may not be accessed during render. (https://react.dev/reference/react/useRef)
 
 error.capture-ref-for-mutation.ts:12:13
   10 |   };
   11 |   const moveLeft = {
 > 12 |     handler: handleKey('left')(),
-     |              ^^^^^^^^^^^^^^^^^ This function accesses a ref value
+     |              ^^^^^^^^^^^^^^^^^ This function accesses a ref value (the `current` property), which may not be accessed during render. (https://react.dev/reference/react/useRef)
   13 |   };
   14 |   const moveRight = {
   15 |     handler: handleKey('right')(),
 
-Error: Cannot access refs during render
+Error: Ref values (the `current` property) may not be accessed during render. (https://react.dev/reference/react/useRef)
 
-React refs are values that are not needed for rendering. Refs should only be accessed outside of render, such as in event handlers or effects. Accessing a ref value (the `current` property) during render can cause your component not to update as expected (https://react.dev/reference/react/useRef)
+error.capture-ref-for-mutation.ts:12:13
+  10 |   };
+  11 |   const moveLeft = {
+> 12 |     handler: handleKey('left')(),
+     |              ^^^^^^^^^^^^^^^^^ Ref values (the `current` property) may not be accessed during render. (https://react.dev/reference/react/useRef)
+  13 |   };
+  14 |   const moveRight = {
+  15 |     handler: handleKey('right')(),
+
+Error: This function accesses a ref value (the `current` property), which may not be accessed during render. (https://react.dev/reference/react/useRef)
 
 error.capture-ref-for-mutation.ts:15:13
   13 |   };
   14 |   const moveRight = {
 > 15 |     handler: handleKey('right')(),
-     |              ^^^^^^^^^^^^^^^^^^ This function accesses a ref value
+     |              ^^^^^^^^^^^^^^^^^^ This function accesses a ref value (the `current` property), which may not be accessed during render. (https://react.dev/reference/react/useRef)
+  16 |   };
+  17 |   return [moveLeft, moveRight];
+  18 | }
+
+Error: Ref values (the `current` property) may not be accessed during render. (https://react.dev/reference/react/useRef)
+
+error.capture-ref-for-mutation.ts:15:13
+  13 |   };
+  14 |   const moveRight = {
+> 15 |     handler: handleKey('right')(),
+     |              ^^^^^^^^^^^^^^^^^^ Ref values (the `current` property) may not be accessed during render. (https://react.dev/reference/react/useRef)
   16 |   };
   17 |   return [moveLeft, moveRight];
   18 | }

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.hook-ref-value.expect.md

@@ -22,28 +22,24 @@ export const FIXTURE_ENTRYPOINT = {
 ```
 Found 2 errors:
 
-Error: Cannot access refs during render
-
-React refs are values that are not needed for rendering. Refs should only be accessed outside of render, such as in event handlers or effects. Accessing a ref value (the `current` property) during render can cause your component not to update as expected (https://react.dev/reference/react/useRef)
+Error: Ref values (the `current` property) may not be accessed during render. (https://react.dev/reference/react/useRef)
 
 error.hook-ref-value.ts:5:23
   3 | function Component(props) {
   4 |   const ref = useRef();
 > 5 |   useEffect(() => {}, [ref.current]);
-    |                        ^^^^^^^^^^^ Cannot access ref value during render
+    |                        ^^^^^^^^^^^ Ref values (the `current` property) may not be accessed during render. (https://react.dev/reference/react/useRef)
   6 | }
   7 |
   8 | export const FIXTURE_ENTRYPOINT = {
 
-Error: Cannot access refs during render
-
-React refs are values that are not needed for rendering. Refs should only be accessed outside of render, such as in event handlers or effects. Accessing a ref value (the `current` property) during render can cause your component not to update as expected (https://react.dev/reference/react/useRef)
+Error: Ref values (the `current` property) may not be accessed during render. (https://react.dev/reference/react/useRef)
 
 error.hook-ref-value.ts:5:23
   3 | function Component(props) {
   4 |   const ref = useRef();
 > 5 |   useEffect(() => {}, [ref.current]);
-    |                        ^^^^^^^^^^^ Cannot access ref value during render
+    |                        ^^^^^^^^^^^ Ref values (the `current` property) may not be accessed during render. (https://react.dev/reference/react/useRef)
   6 | }
   7 |
   8 | export const FIXTURE_ENTRYPOINT = {

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.invalid-access-ref-during-render.expect.md

@@ -17,15 +17,13 @@ function Component(props) {
 ```
 Found 1 error:
 
-Error: Cannot access refs during render
-
-React refs are values that are not needed for rendering. Refs should only be accessed outside of render, such as in event handlers or effects. Accessing a ref value (the `current` property) during render can cause your component not to update as expected (https://react.dev/reference/react/useRef)
+Error: Ref values (the `current` property) may not be accessed during render. (https://react.dev/reference/react/useRef)
 
 error.invalid-access-ref-during-render.ts:4:16
   2 | function Component(props) {
   3 |   const ref = useRef(null);
 > 4 |   const value = ref.current;
-    |                 ^^^^^^^^^^^ Cannot access ref value during render
+    |                 ^^^^^^^^^^^ Ref values (the `current` property) may not be accessed during render. (https://react.dev/reference/react/useRef)
   5 |   return value;
   6 | }
   7 |

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.invalid-aliased-ref-in-callback-invoked-during-render-.expect.md

@@ -21,15 +21,13 @@ function Component(props) {
 ```
 Found 1 error:
 
-Error: Cannot access refs during render
-
-React refs are values that are not needed for rendering. Refs should only be accessed outside of render, such as in event handlers or effects. Accessing a ref value (the `current` property) during render can cause your component not to update as expected (https://react.dev/reference/react/useRef)
+Error: Ref values (the `current` property) may not be accessed during render. (https://react.dev/reference/react/useRef)
 
 error.invalid-aliased-ref-in-callback-invoked-during-render-.ts:9:33
    7 |     return <Foo item={item} current={current} />;
    8 |   };
 >  9 |   return <Items>{props.items.map(item => renderItem(item))}</Items>;
-     |                                  ^^^^^^^^^^^^^^^^^^^^^^^^ Passing a ref to a function may read its value during render
+     |                                  ^^^^^^^^^^^^^^^^^^^^^^^^ Ref values (the `current` property) may not be accessed during render. (https://react.dev/reference/react/useRef)
   10 | }
   11 |
 ```

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.invalid-assign-current-inferred-ref-during-render.expect.md

@@ -1,36 +0,0 @@
-
-## Input
-
-```javascript
-// @flow @enableTreatRefLikeIdentifiersAsRefs @validateRefAccessDuringRender
-import {makeObject_Primitives} from 'shared-runtime';
-
-component Example() {
-  const fooRef = makeObject_Primitives();
-  fooRef.current = true;
-
-  return <Stringify foo={fooRef} />;
-}
-
-```
-
-
-## Error
-
-```
-Found 1 error:
-
-Error: Cannot access refs during render
-
-React refs are values that are not needed for rendering. Refs should only be accessed outside of render, such as in event handlers or effects. Accessing a ref value (the `current` property) during render can cause your component not to update as expected (https://react.dev/reference/react/useRef)
-
-  4 | component Example() {
-  5 |   const fooRef = makeObject_Primitives();
-> 6 |   fooRef.current = true;
-    |   ^^^^^^^^^^^^^^ Cannot update ref during render
-  7 |
-  8 |   return <Stringify foo={fooRef} />;
-  9 | }
-```
-          
-      

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.invalid-assign-current-inferred-ref-during-render.js

@@ -1,9 +0,0 @@
-// @flow @enableTreatRefLikeIdentifiersAsRefs @validateRefAccessDuringRender
-import {makeObject_Primitives} from 'shared-runtime';
-
-component Example() {
-  const fooRef = makeObject_Primitives();
-  fooRef.current = true;
-
-  return <Stringify foo={fooRef} />;
-}

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.invalid-disallow-mutating-ref-in-render.expect.md

@@ -18,15 +18,13 @@ function Component() {
 ```
 Found 1 error:
 
-Error: Cannot access refs during render
-
-React refs are values that are not needed for rendering. Refs should only be accessed outside of render, such as in event handlers or effects. Accessing a ref value (the `current` property) during render can cause your component not to update as expected (https://react.dev/reference/react/useRef)
+Error: Ref values (the `current` property) may not be accessed during render. (https://react.dev/reference/react/useRef)
 
 error.invalid-disallow-mutating-ref-in-render.ts:4:2
   2 | function Component() {
   3 |   const ref = useRef(null);
 > 4 |   ref.current = false;
-    |   ^^^^^^^^^^^ Cannot update ref during render
+    |   ^^^^^^^^^^^ Ref values (the `current` property) may not be accessed during render. (https://react.dev/reference/react/useRef)
   5 |
   6 |   return <button ref={ref} />;
   7 | }

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.invalid-disallow-mutating-refs-in-render-transitive.expect.md

@@ -21,17 +21,26 @@ function Component() {
 ## Error
 
 ```
-Found 1 error:
+Found 2 errors:
 
-Error: Cannot access refs during render
-
-React refs are values that are not needed for rendering. Refs should only be accessed outside of render, such as in event handlers or effects. Accessing a ref value (the `current` property) during render can cause your component not to update as expected (https://react.dev/reference/react/useRef)
+Error: This function accesses a ref value (the `current` property), which may not be accessed during render. (https://react.dev/reference/react/useRef)
 
 error.invalid-disallow-mutating-refs-in-render-transitive.ts:9:2
    7 |   };
    8 |   const changeRef = setRef;
 >  9 |   changeRef();
-     |   ^^^^^^^^^ This function accesses a ref value
+     |   ^^^^^^^^^ This function accesses a ref value (the `current` property), which may not be accessed during render. (https://react.dev/reference/react/useRef)
+  10 |
+  11 |   return <button ref={ref} />;
+  12 | }
+
+Error: Ref values (the `current` property) may not be accessed during render. (https://react.dev/reference/react/useRef)
+
+error.invalid-disallow-mutating-refs-in-render-transitive.ts:9:2
+   7 |   };
+   8 |   const changeRef = setRef;
+>  9 |   changeRef();
+     |   ^^^^^^^^^ Ref values (the `current` property) may not be accessed during render. (https://react.dev/reference/react/useRef)
   10 |
   11 |   return <button ref={ref} />;
   12 | }

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.invalid-mutate-phi-which-could-be-frozen.expect.md

@@ -1,39 +0,0 @@
-
-## Input
-
-```javascript
-import {useHook} from 'shared-runtime';
-
-function Component(props) {
-  const frozen = useHook();
-  let x;
-  if (props.cond) {
-    x = frozen;
-  } else {
-    x = {};
-  }
-  x.property = true;
-}
-
-```
-
-
-## Error
-
-```
-Found 1 error:
-
-Error: This value cannot be modified
-
-Modifying a value returned from a hook is not allowed. Consider moving the modification into the hook where the value is constructed.
-
-error.invalid-mutate-phi-which-could-be-frozen.ts:11:2
-   9 |     x = {};
-  10 |   }
-> 11 |   x.property = true;
-     |   ^ value cannot be modified
-  12 | }
-  13 |
-```
-          
-      

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.invalid-mutate-phi-which-could-be-frozen.js

@@ -1,12 +0,0 @@
-import {useHook} from 'shared-runtime';
-
-function Component(props) {
-  const frozen = useHook();
-  let x;
-  if (props.cond) {
-    x = frozen;
-  } else {
-    x = {};
-  }
-  x.property = true;
-}

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.invalid-pass-ref-to-function.expect.md

@@ -17,15 +17,13 @@ function Component(props) {
 ```
 Found 1 error:
 
-Error: Cannot access refs during render
-
-React refs are values that are not needed for rendering. Refs should only be accessed outside of render, such as in event handlers or effects. Accessing a ref value (the `current` property) during render can cause your component not to update as expected (https://react.dev/reference/react/useRef)
+Error: Ref values (the `current` property) may not be accessed during render. (https://react.dev/reference/react/useRef)
 
 error.invalid-pass-ref-to-function.ts:4:16
   2 | function Component(props) {
   3 |   const ref = useRef(null);
 > 4 |   const x = foo(ref);
-    |                 ^^^ Passing a ref to a function may read its value during render
+    |                 ^^^ Ref values (the `current` property) may not be accessed during render. (https://react.dev/reference/react/useRef)
   5 |   return x.current;
   6 | }
   7 |

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.invalid-read-ref-prop-in-render-destructure.expect.md

@@ -16,15 +16,13 @@ function Component({ref}) {
 ```
 Found 1 error:
 
-Error: Cannot access refs during render
-
-React refs are values that are not needed for rendering. Refs should only be accessed outside of render, such as in event handlers or effects. Accessing a ref value (the `current` property) during render can cause your component not to update as expected (https://react.dev/reference/react/useRef)
+Error: Ref values (the `current` property) may not be accessed during render. (https://react.dev/reference/react/useRef)
 
 error.invalid-read-ref-prop-in-render-destructure.ts:3:16
   1 | // @validateRefAccessDuringRender @compilationMode:"infer"
   2 | function Component({ref}) {
 > 3 |   const value = ref.current;
-    |                 ^^^^^^^^^^^ Cannot access ref value during render
+    |                 ^^^^^^^^^^^ Ref values (the `current` property) may not be accessed during render. (https://react.dev/reference/react/useRef)
   4 |   return <div>{value}</div>;
   5 | }
   6 |

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.invalid-read-ref-prop-in-render-property-load.expect.md

@@ -16,15 +16,13 @@ function Component(props) {
 ```
 Found 1 error:
 
-Error: Cannot access refs during render
-
-React refs are values that are not needed for rendering. Refs should only be accessed outside of render, such as in event handlers or effects. Accessing a ref value (the `current` property) during render can cause your component not to update as expected (https://react.dev/reference/react/useRef)
+Error: Ref values (the `current` property) may not be accessed during render. (https://react.dev/reference/react/useRef)
 
 error.invalid-read-ref-prop-in-render-property-load.ts:3:16
   1 | // @validateRefAccessDuringRender @compilationMode:"infer"
   2 | function Component(props) {
 > 3 |   const value = props.ref.current;
-    |                 ^^^^^^^^^^^^^^^^^ Cannot access ref value during render
+    |                 ^^^^^^^^^^^^^^^^^ Ref values (the `current` property) may not be accessed during render. (https://react.dev/reference/react/useRef)
   4 |   return <div>{value}</div>;
   5 | }
   6 |

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.invalid-ref-in-callback-invoked-during-render.expect.md

@@ -20,15 +20,13 @@ function Component(props) {
 ```
 Found 1 error:
 
-Error: Cannot access refs during render
-
-React refs are values that are not needed for rendering. Refs should only be accessed outside of render, such as in event handlers or effects. Accessing a ref value (the `current` property) during render can cause your component not to update as expected (https://react.dev/reference/react/useRef)
+Error: Ref values (the `current` property) may not be accessed during render. (https://react.dev/reference/react/useRef)
 
 error.invalid-ref-in-callback-invoked-during-render.ts:8:33
    6 |     return <Foo item={item} current={current} />;
    7 |   };
 >  8 |   return <Items>{props.items.map(item => renderItem(item))}</Items>;
-     |                                  ^^^^^^^^^^^^^^^^^^^^^^^^ Passing a ref to a function may read its value during render
+     |                                  ^^^^^^^^^^^^^^^^^^^^^^^^ Ref values (the `current` property) may not be accessed during render. (https://react.dev/reference/react/useRef)
    9 | }
   10 |
 ```

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.invalid-ref-value-as-props.expect.md

@@ -16,15 +16,13 @@ function Component(props) {
 ```
 Found 1 error:
 
-Error: Cannot access refs during render
-
-React refs are values that are not needed for rendering. Refs should only be accessed outside of render, such as in event handlers or effects. Accessing a ref value (the `current` property) during render can cause your component not to update as expected (https://react.dev/reference/react/useRef)
+Error: Ref values (the `current` property) may not be accessed during render. (https://react.dev/reference/react/useRef)
 
 error.invalid-ref-value-as-props.ts:4:19
   2 | function Component(props) {
   3 |   const ref = useRef(null);
 > 4 |   return <Foo ref={ref.current} />;
-    |                    ^^^^^^^^^^^ Cannot access ref value during render
+    |                    ^^^^^^^^^^^ Ref values (the `current` property) may not be accessed during render. (https://react.dev/reference/react/useRef)
   5 | }
   6 |
 ```

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.invalid-set-and-read-ref-during-render.expect.md

@@ -17,28 +17,24 @@ function Component(props) {
 ```
 Found 2 errors:
 
-Error: Cannot access refs during render
-
-React refs are values that are not needed for rendering. Refs should only be accessed outside of render, such as in event handlers or effects. Accessing a ref value (the `current` property) during render can cause your component not to update as expected (https://react.dev/reference/react/useRef)
+Error: Ref values (the `current` property) may not be accessed during render. (https://react.dev/reference/react/useRef)
 
 error.invalid-set-and-read-ref-during-render.ts:4:2
   2 | function Component(props) {
   3 |   const ref = useRef(null);
 > 4 |   ref.current = props.value;
-    |   ^^^^^^^^^^^ Cannot update ref during render
+    |   ^^^^^^^^^^^ Ref values (the `current` property) may not be accessed during render. (https://react.dev/reference/react/useRef)
   5 |   return ref.current;
   6 | }
   7 |
 
-Error: Cannot access refs during render
-
-React refs are values that are not needed for rendering. Refs should only be accessed outside of render, such as in event handlers or effects. Accessing a ref value (the `current` property) during render can cause your component not to update as expected (https://react.dev/reference/react/useRef)
+Error: Ref values (the `current` property) may not be accessed during render. (https://react.dev/reference/react/useRef)
 
 error.invalid-set-and-read-ref-during-render.ts:5:9
   3 |   const ref = useRef(null);
   4 |   ref.current = props.value;
 > 5 |   return ref.current;
-    |          ^^^^^^^^^^^ Cannot access ref value during render
+    |          ^^^^^^^^^^^ Ref values (the `current` property) may not be accessed during render. (https://react.dev/reference/react/useRef)
   6 | }
   7 |
 ```

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.invalid-set-and-read-ref-nested-property-during-render.expect.md

@@ -17,28 +17,24 @@ function Component(props) {
 ```
 Found 2 errors:
 
-Error: Cannot access refs during render
-
-React refs are values that are not needed for rendering. Refs should only be accessed outside of render, such as in event handlers or effects. Accessing a ref value (the `current` property) during render can cause your component not to update as expected (https://react.dev/reference/react/useRef)
+Error: Ref values (the `current` property) may not be accessed during render. (https://react.dev/reference/react/useRef)
 
 error.invalid-set-and-read-ref-nested-property-during-render.ts:4:2
   2 | function Component(props) {
   3 |   const ref = useRef({inner: null});
 > 4 |   ref.current.inner = props.value;
-    |   ^^^^^^^^^^^ Cannot update ref during render
+    |   ^^^^^^^^^^^ Ref values (the `current` property) may not be accessed during render. (https://react.dev/reference/react/useRef)
   5 |   return ref.current.inner;
   6 | }
   7 |
 
-Error: Cannot access refs during render
-
-React refs are values that are not needed for rendering. Refs should only be accessed outside of render, such as in event handlers or effects. Accessing a ref value (the `current` property) during render can cause your component not to update as expected (https://react.dev/reference/react/useRef)
+Error: Ref values (the `current` property) may not be accessed during render. (https://react.dev/reference/react/useRef)
 
 error.invalid-set-and-read-ref-nested-property-during-render.ts:5:9
   3 |   const ref = useRef({inner: null});
   4 |   ref.current.inner = props.value;
 > 5 |   return ref.current.inner;
-    |          ^^^^^^^^^^^^^^^^^ Cannot access ref value during render
+    |          ^^^^^^^^^^^^^^^^^ Ref values (the `current` property) may not be accessed during render. (https://react.dev/reference/react/useRef)
   6 | }
   7 |
 ```

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.invalid-sketchy-code-use-forget.expect.md

@@ -19,26 +19,26 @@ function lowercasecomponent() {
 ```
 Found 2 errors:
 
-Error: React Compiler has skipped optimizing this component because one or more React ESLint rules were disabled
+Error: React Compiler has skipped optimizing this component because one or more React ESLint rules were disabled. React Compiler only works when your components follow all the rules of React, disabling them may result in unexpected or incorrect behavior
 
-React Compiler only works when your components follow all the rules of React, disabling them may result in unexpected or incorrect behavior. Found suppression `eslint-disable react-hooks/rules-of-hooks`
+eslint-disable react-hooks/rules-of-hooks.
 
 error.invalid-sketchy-code-use-forget.ts:1:0
 > 1 | /* eslint-disable react-hooks/rules-of-hooks */
-    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Found React rule suppression
+    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ React Compiler has skipped optimizing this component because one or more React ESLint rules were disabled. React Compiler only works when your components follow all the rules of React, disabling them may result in unexpected or incorrect behavior
   2 | function lowercasecomponent() {
   3 |   'use forget';
   4 |   const x = [];
 
-Error: React Compiler has skipped optimizing this component because one or more React ESLint rules were disabled
+Error: React Compiler has skipped optimizing this component because one or more React ESLint rules were disabled. React Compiler only works when your components follow all the rules of React, disabling them may result in unexpected or incorrect behavior
 
-React Compiler only works when your components follow all the rules of React, disabling them may result in unexpected or incorrect behavior. Found suppression `eslint-disable-next-line react-hooks/rules-of-hooks`
+eslint-disable-next-line react-hooks/rules-of-hooks.
 
 error.invalid-sketchy-code-use-forget.ts:5:2
   3 |   'use forget';
   4 |   const x = [];
 > 5 |   // eslint-disable-next-line react-hooks/rules-of-hooks
-    |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Found React rule suppression
+    |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ React Compiler has skipped optimizing this component because one or more React ESLint rules were disabled. React Compiler only works when your components follow all the rules of React, disabling them may result in unexpected or incorrect behavior
   6 |   return <div>{x}</div>;
   7 | }
   8 | /* eslint-enable react-hooks/rules-of-hooks */

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.invalid-unclosed-eslint-suppression.expect.md

@@ -38,14 +38,14 @@ function CrimesAgainstReact() {
 ```
 Found 1 error:
 
-Error: React Compiler has skipped optimizing this component because one or more React ESLint rules were disabled
+Error: React Compiler has skipped optimizing this component because one or more React ESLint rules were disabled. React Compiler only works when your components follow all the rules of React, disabling them may result in unexpected or incorrect behavior
 
-React Compiler only works when your components follow all the rules of React, disabling them may result in unexpected or incorrect behavior. Found suppression `eslint-disable react-hooks/rules-of-hooks`
+eslint-disable react-hooks/rules-of-hooks.
 
 error.invalid-unclosed-eslint-suppression.ts:2:0
   1 | // Note: Everything below this is sketchy
 > 2 | /* eslint-disable react-hooks/rules-of-hooks */
-    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Found React rule suppression
+    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ React Compiler has skipped optimizing this component because one or more React ESLint rules were disabled. React Compiler only works when your components follow all the rules of React, disabling them may result in unexpected or incorrect behavior
   3 | function lowercasecomponent() {
   4 |   'use forget';
   5 |   const x = [];

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.invalid-use-ref-added-to-dep-without-type-info.expect.md

@@ -24,28 +24,24 @@ function Foo({a}) {
 ```
 Found 2 errors:
 
-Error: Cannot access refs during render
-
-React refs are values that are not needed for rendering. Refs should only be accessed outside of render, such as in event handlers or effects. Accessing a ref value (the `current` property) during render can cause your component not to update as expected (https://react.dev/reference/react/useRef)
+Error: Ref values (the `current` property) may not be accessed during render. (https://react.dev/reference/react/useRef)
 
 error.invalid-use-ref-added-to-dep-without-type-info.ts:10:21
    8 |   // however, this is an instance of accessing a ref during render and is disallowed
    9 |   // under React's rules, so we reject this input
 > 10 |   const x = {a, val: val.ref.current};
-     |                      ^^^^^^^^^^^^^^^ Cannot access ref value during render
+     |                      ^^^^^^^^^^^^^^^ Ref values (the `current` property) may not be accessed during render. (https://react.dev/reference/react/useRef)
   11 |
   12 |   return <VideoList videos={x} />;
   13 | }
 
-Error: Cannot access refs during render
-
-React refs are values that are not needed for rendering. Refs should only be accessed outside of render, such as in event handlers or effects. Accessing a ref value (the `current` property) during render can cause your component not to update as expected (https://react.dev/reference/react/useRef)
+Error: Ref values (the `current` property) may not be accessed during render. (https://react.dev/reference/react/useRef)
 
 error.invalid-use-ref-added-to-dep-without-type-info.ts:10:21
    8 |   // however, this is an instance of accessing a ref during render and is disallowed
    9 |   // under React's rules, so we reject this input
 > 10 |   const x = {a, val: val.ref.current};
-     |                      ^^^^^^^^^^^^^^^ Cannot access ref value during render
+     |                      ^^^^^^^^^^^^^^^ Ref values (the `current` property) may not be accessed during render. (https://react.dev/reference/react/useRef)
   11 |
   12 |   return <VideoList videos={x} />;
   13 | }

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.invalid-write-but-dont-read-ref-in-render.expect.md

@@ -19,15 +19,13 @@ function useHook({value}) {
 ```
 Found 1 error:
 
-Error: Cannot access refs during render
-
-React refs are values that are not needed for rendering. Refs should only be accessed outside of render, such as in event handlers or effects. Accessing a ref value (the `current` property) during render can cause your component not to update as expected (https://react.dev/reference/react/useRef)
+Error: Ref values (the `current` property) may not be accessed during render. (https://react.dev/reference/react/useRef)
 
 error.invalid-write-but-dont-read-ref-in-render.ts:5:2
   3 |   const ref = useRef(null);
   4 |   // Writing to a ref in render is against the rules:
 > 5 |   ref.current = value;
-    |   ^^^^^^^^^^^ Cannot update ref during render
+    |   ^^^^^^^^^^^ Ref values (the `current` property) may not be accessed during render. (https://react.dev/reference/react/useRef)
   6 |   // returning a ref is allowed, so this alone doesn't trigger an error:
   7 |   return ref;
   8 | }

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.invalid-write-ref-prop-in-render.expect.md

@@ -17,15 +17,13 @@ function Component(props) {
 ```
 Found 1 error:
 
-Error: Cannot access refs during render
-
-React refs are values that are not needed for rendering. Refs should only be accessed outside of render, such as in event handlers or effects. Accessing a ref value (the `current` property) during render can cause your component not to update as expected (https://react.dev/reference/react/useRef)
+Error: Ref values (the `current` property) may not be accessed during render. (https://react.dev/reference/react/useRef)
 
 error.invalid-write-ref-prop-in-render.ts:4:2
   2 | function Component(props) {
   3 |   const ref = props.ref;
 > 4 |   ref.current = true;
-    |   ^^^^^^^^^^^ Cannot update ref during render
+    |   ^^^^^^^^^^^ Ref values (the `current` property) may not be accessed during render. (https://react.dev/reference/react/useRef)
   5 |   return <div>{value}</div>;
   6 | }
   7 |

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.ref-initialization-arbitrary.expect.md

@@ -27,26 +27,22 @@ export const FIXTURE_ENTRYPOINT = {
 ```
 Found 2 errors:
 
-Error: Cannot access refs during render
-
-React refs are values that are not needed for rendering. Refs should only be accessed outside of render, such as in event handlers or effects. Accessing a ref value (the `current` property) during render can cause your component not to update as expected (https://react.dev/reference/react/useRef)
+Error: Ref values (the `current` property) may not be accessed during render. (https://react.dev/reference/react/useRef)
 
    6 | component C() {
    7 |   const r = useRef(DEFAULT_VALUE);
 >  8 |   if (r.current == DEFAULT_VALUE) {
-     |       ^^^^^^^^^ Cannot access ref value during render
+     |       ^^^^^^^^^ Ref values (the `current` property) may not be accessed during render. (https://react.dev/reference/react/useRef)
    9 |     r.current = 1;
   10 |   }
   11 | }
 
-Error: Cannot access refs during render
-
-React refs are values that are not needed for rendering. Refs should only be accessed outside of render, such as in event handlers or effects. Accessing a ref value (the `current` property) during render can cause your component not to update as expected (https://react.dev/reference/react/useRef)
+Error: Ref values (the `current` property) may not be accessed during render. (https://react.dev/reference/react/useRef)
 
    7 |   const r = useRef(DEFAULT_VALUE);
    8 |   if (r.current == DEFAULT_VALUE) {
 >  9 |     r.current = 1;
-     |     ^^^^^^^^^ Cannot update ref during render
+     |     ^^^^^^^^^ Ref values (the `current` property) may not be accessed during render. (https://react.dev/reference/react/useRef)
   10 |   }
   11 | }
   12 |

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.ref-initialization-call-2.expect.md

@@ -25,14 +25,12 @@ export const FIXTURE_ENTRYPOINT = {
 ```
 Found 1 error:
 
-Error: Cannot access refs during render
-
-React refs are values that are not needed for rendering. Refs should only be accessed outside of render, such as in event handlers or effects. Accessing a ref value (the `current` property) during render can cause your component not to update as expected (https://react.dev/reference/react/useRef)
+Error: Ref values (the `current` property) may not be accessed during render. (https://react.dev/reference/react/useRef)
 
    5 |   const r = useRef(null);
    6 |   if (r.current == null) {
 >  7 |     f(r);
-     |       ^ Passing a ref to a function may read its value during render
+     |       ^ Ref values (the `current` property) may not be accessed during render. (https://react.dev/reference/react/useRef)
    8 |   }
    9 | }
   10 |

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.ref-initialization-call.expect.md

@@ -25,14 +25,12 @@ export const FIXTURE_ENTRYPOINT = {
 ```
 Found 1 error:
 
-Error: Cannot access refs during render
-
-React refs are values that are not needed for rendering. Refs should only be accessed outside of render, such as in event handlers or effects. Accessing a ref value (the `current` property) during render can cause your component not to update as expected (https://react.dev/reference/react/useRef)
+Error: Ref values (the `current` property) may not be accessed during render. (https://react.dev/reference/react/useRef)
 
    5 |   const r = useRef(null);
    6 |   if (r.current == null) {
 >  7 |     f(r.current);
-     |       ^^^^^^^^^ Passing a ref to a function may read its value during render
+     |       ^^^^^^^^^ Ref values (the `current` property) may not be accessed during render. (https://react.dev/reference/react/useRef)
    8 |   }
    9 | }
   10 |

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.ref-initialization-linear.expect.md

@@ -26,14 +26,12 @@ export const FIXTURE_ENTRYPOINT = {
 ```
 Found 1 error:
 
-Error: Cannot access refs during render
-
-React refs are values that are not needed for rendering. Refs should only be accessed outside of render, such as in event handlers or effects. Accessing a ref value (the `current` property) during render can cause your component not to update as expected (https://react.dev/reference/react/useRef)
+Error: Ref values (the `current` property) may not be accessed during render. (https://react.dev/reference/react/useRef)
 
    6 |   if (r.current == null) {
    7 |     r.current = 42;
 >  8 |     r.current = 42;
-     |     ^^^^^^^^^ Cannot update ref during render
+     |     ^^^^^^^^^ Ref values (the `current` property) may not be accessed during render. (https://react.dev/reference/react/useRef)
    9 |   }
   10 | }
   11 |

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.ref-initialization-nonif.expect.md

@@ -26,26 +26,24 @@ export const FIXTURE_ENTRYPOINT = {
 ```
 Found 2 errors:
 
-Error: Cannot access refs during render
-
-React refs are values that are not needed for rendering. Refs should only be accessed outside of render, such as in event handlers or effects. Accessing a ref value (the `current` property) during render can cause your component not to update as expected (https://react.dev/reference/react/useRef)
+Error: Ref values (the `current` property) may not be accessed during render. (https://react.dev/reference/react/useRef)
 
   4 | component C() {
   5 |   const r = useRef(null);
 > 6 |   const guard = r.current == null;
-    |                 ^^^^^^^^^^^^^^^^^ Cannot access ref value during render
+    |                 ^^^^^^^^^^^^^^^^^ Ref values (the `current` property) may not be accessed during render. (https://react.dev/reference/react/useRef)
   7 |   if (guard) {
   8 |     r.current = 1;
   9 |   }
 
-Error: Cannot access refs during render
+Error: Ref values (the `current` property) may not be accessed during render. (https://react.dev/reference/react/useRef)
 
-React refs are values that are not needed for rendering. Refs should only be accessed outside of render, such as in event handlers or effects. Accessing a ref value (the `current` property) during render can cause your component not to update as expected (https://react.dev/reference/react/useRef)
+Cannot access ref value `guard`.
 
    5 |   const r = useRef(null);
    6 |   const guard = r.current == null;
 >  7 |   if (guard) {
-     |       ^^^^^ Cannot access ref value during render
+     |       ^^^^^ Ref values (the `current` property) may not be accessed during render. (https://react.dev/reference/react/useRef)
    8 |     r.current = 1;
    9 |   }
   10 | }

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.ref-initialization-other.expect.md

@@ -26,14 +26,12 @@ export const FIXTURE_ENTRYPOINT = {
 ```
 Found 1 error:
 
-Error: Cannot access refs during render
-
-React refs are values that are not needed for rendering. Refs should only be accessed outside of render, such as in event handlers or effects. Accessing a ref value (the `current` property) during render can cause your component not to update as expected (https://react.dev/reference/react/useRef)
+Error: Ref values (the `current` property) may not be accessed during render. (https://react.dev/reference/react/useRef)
 
    6 |   const r2 = useRef(null);
    7 |   if (r.current == null) {
 >  8 |     r2.current = 1;
-     |     ^^^^^^^^^^ Cannot update ref during render
+     |     ^^^^^^^^^^ Ref values (the `current` property) may not be accessed during render. (https://react.dev/reference/react/useRef)
    9 |   }
   10 | }
   11 |

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.ref-initialization-post-access-2.expect.md

@@ -26,14 +26,12 @@ export const FIXTURE_ENTRYPOINT = {
 ```
 Found 1 error:
 
-Error: Cannot access refs during render
-
-React refs are values that are not needed for rendering. Refs should only be accessed outside of render, such as in event handlers or effects. Accessing a ref value (the `current` property) during render can cause your component not to update as expected (https://react.dev/reference/react/useRef)
+Error: Ref values (the `current` property) may not be accessed during render. (https://react.dev/reference/react/useRef)
 
    7 |     r.current = 1;
    8 |   }
 >  9 |   f(r.current);
-     |     ^^^^^^^^^ Passing a ref to a function may read its value during render
+     |     ^^^^^^^^^ Ref values (the `current` property) may not be accessed during render. (https://react.dev/reference/react/useRef)
   10 | }
   11 |
   12 | export const FIXTURE_ENTRYPOINT = {

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.ref-initialization-post-access.expect.md

@@ -26,14 +26,12 @@ export const FIXTURE_ENTRYPOINT = {
 ```
 Found 1 error:
 
-Error: Cannot access refs during render
-
-React refs are values that are not needed for rendering. Refs should only be accessed outside of render, such as in event handlers or effects. Accessing a ref value (the `current` property) during render can cause your component not to update as expected (https://react.dev/reference/react/useRef)
+Error: Ref values (the `current` property) may not be accessed during render. (https://react.dev/reference/react/useRef)
 
    7 |     r.current = 1;
    8 |   }
 >  9 |   r.current = 1;
-     |   ^^^^^^^^^ Cannot update ref during render
+     |   ^^^^^^^^^ Ref values (the `current` property) may not be accessed during render. (https://react.dev/reference/react/useRef)
   10 | }
   11 |
   12 | export const FIXTURE_ENTRYPOINT = {

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.ref-optional.expect.md

@@ -22,15 +22,13 @@ export const FIXTURE_ENTRYPOINT = {
 ```
 Found 1 error:
 
-Error: Cannot access refs during render
-
-React refs are values that are not needed for rendering. Refs should only be accessed outside of render, such as in event handlers or effects. Accessing a ref value (the `current` property) during render can cause your component not to update as expected (https://react.dev/reference/react/useRef)
+Error: Ref values (the `current` property) may not be accessed during render. (https://react.dev/reference/react/useRef)
 
 error.ref-optional.ts:5:9
   3 | function Component(props) {
   4 |   const ref = useRef();
 > 5 |   return ref?.current;
-    |          ^^^^^^^^^^^^ Cannot access ref value during render
+    |          ^^^^^^^^^^^^ Ref values (the `current` property) may not be accessed during render. (https://react.dev/reference/react/useRef)
   6 | }
   7 |
   8 | export const FIXTURE_ENTRYPOINT = {

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.repro-ref-mutable-range.expect.md

@@ -30,15 +30,13 @@ export const FIXTURE_ENTRYPOINT = {
 ```
 Found 1 error:
 
-Error: Cannot access refs during render
-
-React refs are values that are not needed for rendering. Refs should only be accessed outside of render, such as in event handlers or effects. Accessing a ref value (the `current` property) during render can cause your component not to update as expected (https://react.dev/reference/react/useRef)
+Error: Ref values (the `current` property) may not be accessed during render. (https://react.dev/reference/react/useRef)
 
 error.repro-ref-mutable-range.ts:11:36
    9 |   mutate(value);
   10 |   if (CONST_TRUE) {
 > 11 |     return <Stringify ref={identity(ref)} />;
-     |                                     ^^^ Passing a ref to a function may read its value during render
+     |                                     ^^^ Ref values (the `current` property) may not be accessed during render. (https://react.dev/reference/react/useRef)
   12 |   }
   13 |   return value;
   14 | }

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.sketchy-code-exhaustive-deps.expect.md

@@ -22,15 +22,15 @@ function Component() {
 ```
 Found 1 error:
 
-Error: React Compiler has skipped optimizing this component because one or more React ESLint rules were disabled
+Error: React Compiler has skipped optimizing this component because one or more React ESLint rules were disabled. React Compiler only works when your components follow all the rules of React, disabling them may result in unexpected or incorrect behavior
 
-React Compiler only works when your components follow all the rules of React, disabling them may result in unexpected or incorrect behavior. Found suppression `eslint-disable-next-line react-hooks/exhaustive-deps`
+eslint-disable-next-line react-hooks/exhaustive-deps.
 
 error.sketchy-code-exhaustive-deps.ts:6:7
   4 |     () => {
   5 |       item.push(1);
 > 6 |     }, // eslint-disable-next-line react-hooks/exhaustive-deps
-    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Found React rule suppression
+    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ React Compiler has skipped optimizing this component because one or more React ESLint rules were disabled. React Compiler only works when your components follow all the rules of React, disabling them may result in unexpected or incorrect behavior
   7 |     []
   8 |   );
   9 |

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.sketchy-code-rules-of-hooks.expect.md

@@ -23,13 +23,13 @@ export const FIXTURE_ENTRYPOINT = {
 ```
 Found 1 error:
 
-Error: React Compiler has skipped optimizing this component because one or more React ESLint rules were disabled
+Error: React Compiler has skipped optimizing this component because one or more React ESLint rules were disabled. React Compiler only works when your components follow all the rules of React, disabling them may result in unexpected or incorrect behavior
 
-React Compiler only works when your components follow all the rules of React, disabling them may result in unexpected or incorrect behavior. Found suppression `eslint-disable react-hooks/rules-of-hooks`
+eslint-disable react-hooks/rules-of-hooks.
 
 error.sketchy-code-rules-of-hooks.ts:1:0
 > 1 | /* eslint-disable react-hooks/rules-of-hooks */
-    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Found React rule suppression
+    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ React Compiler has skipped optimizing this component because one or more React ESLint rules were disabled. React Compiler only works when your components follow all the rules of React, disabling them may result in unexpected or incorrect behavior
   2 | function lowercasecomponent() {
   3 |   const x = [];
   4 |   return <div>{x}</div>;

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.todo-for-loop-with-context-variable-iterator.expect.md

@@ -1,61 +0,0 @@
-
-## Input
-
-```javascript
-import {Stringify, useIdentity} from 'shared-runtime';
-
-function Component() {
-  const data = useIdentity(
-    new Map([
-      [0, 'value0'],
-      [1, 'value1'],
-    ])
-  );
-  const items = [];
-  // NOTE: `i` is a context variable because it's reassigned and also referenced
-  // within a closure, the `onClick` handler of each item
-  // TODO: for loops create a unique environment on each iteration, which means
-  // that if the iteration variable is only updated in the updater, the variable
-  // is effectively const within the body and the "update" acts more like
-  // a re-initialization than a reassignment.
-  // Until we model this "new environment" semantic, we allow this case to error
-  for (let i = MIN; i <= MAX; i += INCREMENT) {
-    items.push(
-      <Stringify key={i} onClick={() => data.get(i)} shouldInvokeFns={true} />
-    );
-  }
-  return <>{items}</>;
-}
-
-const MIN = 0;
-const MAX = 3;
-const INCREMENT = 1;
-
-export const FIXTURE_ENTRYPOINT = {
-  params: [],
-  fn: Component,
-};
-
-```
-
-
-## Error
-
-```
-Found 1 error:
-
-Error: This value cannot be modified
-
-Modifying a value used previously in JSX is not allowed. Consider moving the modification before the JSX.
-
-error.todo-for-loop-with-context-variable-iterator.ts:18:30
-  16 |   // a re-initialization than a reassignment.
-  17 |   // Until we model this "new environment" semantic, we allow this case to error
-> 18 |   for (let i = MIN; i <= MAX; i += INCREMENT) {
-     |                               ^ `i` cannot be modified
-  19 |     items.push(
-  20 |       <Stringify key={i} onClick={() => data.get(i)} shouldInvokeFns={true} />
-  21 |     );
-```
-          
-      

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.todo-useCallback-set-ref-nested-property-ref-modified-later-preserve-memoization.expect.md

@@ -33,15 +33,13 @@ export const FIXTURE_ENTRYPOINT = {
 ```
 Found 1 error:
 
-Error: Cannot access refs during render
-
-React refs are values that are not needed for rendering. Refs should only be accessed outside of render, such as in event handlers or effects. Accessing a ref value (the `current` property) during render can cause your component not to update as expected (https://react.dev/reference/react/useRef)
+Error: Ref values (the `current` property) may not be accessed during render. (https://react.dev/reference/react/useRef)
 
 error.todo-useCallback-set-ref-nested-property-ref-modified-later-preserve-memoization.ts:14:2
   12 |
   13 |   // The ref is modified later, extending its range and preventing memoization of onChange
 > 14 |   ref.current.inner = null;
-     |   ^^^^^^^^^^^ Cannot update ref during render
+     |   ^^^^^^^^^^^ Ref values (the `current` property) may not be accessed during render. (https://react.dev/reference/react/useRef)
   15 |
   16 |   return <input onChange={onChange} />;
   17 | }

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.useCallback-accesses-ref-mutated-later-via-function-preserve-memoization.expect.md

@@ -34,17 +34,26 @@ export const FIXTURE_ENTRYPOINT = {
 ## Error
 
 ```
-Found 1 error:
+Found 2 errors:
 
-Error: Cannot access refs during render
-
-React refs are values that are not needed for rendering. Refs should only be accessed outside of render, such as in event handlers or effects. Accessing a ref value (the `current` property) during render can cause your component not to update as expected (https://react.dev/reference/react/useRef)
+Error: This function accesses a ref value (the `current` property), which may not be accessed during render. (https://react.dev/reference/react/useRef)
 
 error.useCallback-accesses-ref-mutated-later-via-function-preserve-memoization.ts:17:2
   15 |     ref.current.inner = null;
   16 |   };
 > 17 |   reset();
-     |   ^^^^^ This function accesses a ref value
+     |   ^^^^^ This function accesses a ref value (the `current` property), which may not be accessed during render. (https://react.dev/reference/react/useRef)
+  18 |
+  19 |   return <input onChange={onChange} />;
+  20 | }
+
+Error: Ref values (the `current` property) may not be accessed during render. (https://react.dev/reference/react/useRef)
+
+error.useCallback-accesses-ref-mutated-later-via-function-preserve-memoization.ts:17:2
+  15 |     ref.current.inner = null;
+  16 |   };
+> 17 |   reset();
+     |   ^^^^^ Ref values (the `current` property) may not be accessed during render. (https://react.dev/reference/react/useRef)
   18 |
   19 |   return <input onChange={onChange} />;
   20 | }

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.useCallback-set-ref-nested-property-dont-preserve-memoization.expect.md

@@ -32,15 +32,13 @@ export const FIXTURE_ENTRYPOINT = {
 ```
 Found 1 error:
 
-Error: Cannot access refs during render
-
-React refs are values that are not needed for rendering. Refs should only be accessed outside of render, such as in event handlers or effects. Accessing a ref value (the `current` property) during render can cause your component not to update as expected (https://react.dev/reference/react/useRef)
+Error: Ref values (the `current` property) may not be accessed during render. (https://react.dev/reference/react/useRef)
 
 error.useCallback-set-ref-nested-property-dont-preserve-memoization.ts:13:2
   11 |   });
   12 |
 > 13 |   ref.current.inner = null;
-     |   ^^^^^^^^^^^ Cannot update ref during render
+     |   ^^^^^^^^^^^ Ref values (the `current` property) may not be accessed during render. (https://react.dev/reference/react/useRef)
   14 |
   15 |   return <input onChange={onChange} />;
   16 | }

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.useMemo-no-return-value.expect.md

@@ -1,64 +0,0 @@
-
-## Input
-
-```javascript
-// @validateNoVoidUseMemo
-function Component() {
-  const value = useMemo(() => {
-    console.log('computing');
-  }, []);
-  const value2 = React.useMemo(() => {
-    console.log('computing');
-  }, []);
-  return (
-    <div>
-      {value}
-      {value2}
-    </div>
-  );
-}
-
-```
-
-
-## Error
-
-```
-Found 2 errors:
-
-Error: useMemo() callbacks must return a value
-
-This useMemo callback doesn't return a value. useMemo is for computing and caching values, not for arbitrary side effects.
-
-error.useMemo-no-return-value.ts:3:16
-  1 | // @validateNoVoidUseMemo
-  2 | function Component() {
-> 3 |   const value = useMemo(() => {
-    |                 ^^^^^^^^^^^^^^^
-> 4 |     console.log('computing');
-    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-> 5 |   }, []);
-    | ^^^^^^^^^ useMemo() callbacks must return a value
-  6 |   const value2 = React.useMemo(() => {
-  7 |     console.log('computing');
-  8 |   }, []);
-
-Error: useMemo() callbacks must return a value
-
-This React.useMemo callback doesn't return a value. useMemo is for computing and caching values, not for arbitrary side effects.
-
-error.useMemo-no-return-value.ts:6:17
-   4 |     console.log('computing');
-   5 |   }, []);
->  6 |   const value2 = React.useMemo(() => {
-     |                  ^^^^^^^^^^^^^^^^^^^^^
->  7 |     console.log('computing');
-     | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->  8 |   }, []);
-     | ^^^^^^^^^ useMemo() callbacks must return a value
-   9 |   return (
-  10 |     <div>
-  11 |       {value}
-```
-          
-      

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.useMemo-no-return-value.js

@@ -1,15 +0,0 @@
-// @validateNoVoidUseMemo
-function Component() {
-  const value = useMemo(() => {
-    console.log('computing');
-  }, []);
-  const value2 = React.useMemo(() => {
-    console.log('computing');
-  }, []);
-  return (
-    <div>
-      {value}
-      {value2}
-    </div>
-  );
-}

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.useMemo-non-literal-depslist.expect.md

@@ -32,8 +32,6 @@ Found 1 error:
 
 Error: Expected the dependency list for useMemo to be an array literal
 
-Expected the dependency list for useMemo to be an array literal
-
 error.useMemo-non-literal-depslist.ts:10:4
    8 |       return text.toUpperCase();
    9 |     },

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.validate-mutate-ref-arg-in-render.expect.md

@@ -22,15 +22,13 @@ export const FIXTURE_ENTRYPOINT = {
 ```
 Found 1 error:
 
-Error: Cannot access refs during render
-
-React refs are values that are not needed for rendering. Refs should only be accessed outside of render, such as in event handlers or effects. Accessing a ref value (the `current` property) during render can cause your component not to update as expected (https://react.dev/reference/react/useRef)
+Error: Ref values (the `current` property) may not be accessed during render. (https://react.dev/reference/react/useRef)
 
 error.validate-mutate-ref-arg-in-render.ts:3:14
   1 | // @validateRefAccessDuringRender:true
   2 | function Foo(props, ref) {
 > 3 |   console.log(ref.current);
-    |               ^^^^^^^^^^^ Passing a ref to a function may read its value during render
+    |               ^^^^^^^^^^^ Ref values (the `current` property) may not be accessed during render. (https://react.dev/reference/react/useRef)
   4 |   return <div>{props.bar}</div>;
   5 | }
   6 |

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/for-loop-with-context-variable-iterator.expect.md

@@ -0,0 +1,89 @@
+
+## Input
+
+```javascript
+import {Stringify, useIdentity} from 'shared-runtime';
+
+function Component() {
+  const data = useIdentity(
+    new Map([
+      [0, 'value0'],
+      [1, 'value1'],
+    ])
+  );
+  const items = [];
+  // NOTE: `i` is a context variable because it's reassigned and also referenced
+  // within a closure, the `onClick` handler of each item
+  for (let i = MIN; i <= MAX; i += INCREMENT) {
+    items.push(
+      <Stringify key={i} onClick={() => data.get(i)} shouldInvokeFns={true} />
+    );
+  }
+  return <>{items}</>;
+}
+
+const MIN = 0;
+const MAX = 3;
+const INCREMENT = 1;
+
+export const FIXTURE_ENTRYPOINT = {
+  params: [],
+  fn: Component,
+};
+
+```
+
+## Code
+
+```javascript
+import { c as _c } from "react/compiler-runtime";
+import { Stringify, useIdentity } from "shared-runtime";
+
+function Component() {
+  const $ = _c(3);
+  let t0;
+  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+    t0 = new Map([
+      [0, "value0"],
+      [1, "value1"],
+    ]);
+    $[0] = t0;
+  } else {
+    t0 = $[0];
+  }
+  const data = useIdentity(t0);
+  let t1;
+  if ($[1] !== data) {
+    const items = [];
+    for (let i = MIN; i <= MAX; i = i + INCREMENT, i) {
+      items.push(
+        <Stringify
+          key={i}
+          onClick={() => data.get(i)}
+          shouldInvokeFns={true}
+        />,
+      );
+    }
+
+    t1 = <>{items}</>;
+    $[1] = data;
+    $[2] = t1;
+  } else {
+    t1 = $[2];
+  }
+  return t1;
+}
+
+const MIN = 0;
+const MAX = 3;
+const INCREMENT = 1;
+
+export const FIXTURE_ENTRYPOINT = {
+  params: [],
+  fn: Component,
+};
+
+```
+      
+### Eval output
+(kind: ok) <div>{"onClick":{"kind":"Function","result":"value0"},"shouldInvokeFns":true}</div><div>{"onClick":{"kind":"Function","result":"value1"},"shouldInvokeFns":true}</div><div>{"onClick":{"kind":"Function"},"shouldInvokeFns":true}</div><div>{"onClick":{"kind":"Function"},"shouldInvokeFns":true}</div>

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/for-loop-with-context-variable-iterator.js

@@ -10,11 +10,6 @@ function Component() {
   const items = [];
   // NOTE: `i` is a context variable because it's reassigned and also referenced
   // within a closure, the `onClick` handler of each item
-  // TODO: for loops create a unique environment on each iteration, which means
-  // that if the iteration variable is only updated in the updater, the variable
-  // is effectively const within the body and the "update" acts more like
-  // a re-initialization than a reassignment.
-  // Until we model this "new environment" semantic, we allow this case to error
   for (let i = MIN; i <= MAX; i += INCREMENT) {
     items.push(
       <Stringify key={i} onClick={() => data.get(i)} shouldInvokeFns={true} />

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/infer-effect-dependencies/error.wrong-index-no-func.expect.md

@@ -16,7 +16,6 @@ function Component({foo}) {
 
 ```
 Found 1 error:
-
 Error: Cannot infer dependencies of this effect. This will break your build!
 
 To resolve, either pass a dependency array or fix reported compiler bailout diagnostics.

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/infer-effect-dependencies/error.wrong-index.expect.md

@@ -23,7 +23,6 @@ function Component({foo}) {
 
 ```
 Found 1 error:
-
 Error: Cannot infer dependencies of this effect. This will break your build!
 
 To resolve, either pass a dependency array or fix reported compiler bailout diagnostics.

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/invalid-setState-in-useEffect-transitive.expect.md

@@ -65,7 +65,7 @@ function _temp(s) {
 ## Logs
 
 ```
-{"kind":"CompileError","detail":{"options":{"category":"Calling setState synchronously within an effect can trigger cascading renders","description":"Effects are intended to synchronize state between React and external systems such as manually updating the DOM, state management libraries, or other platform APIs. In general, the body of an effect should do one or both of the following:\n* Update external systems with the latest state from React.\n* Subscribe for updates from some external system, calling setState in a callback function when external state changes.\n\nCalling setState synchronously within an effect body causes cascading renders that can hurt performance, and is not recommended. (https://react.dev/learn/you-might-not-need-an-effect)","severity":"InvalidReact","suggestions":null,"details":[{"kind":"error","loc":{"start":{"line":13,"column":4,"index":265},"end":{"line":13,"column":5,"index":266},"filename":"invalid-setState-in-useEffect-transitive.ts","identifierName":"g"},"message":"Avoid calling setState() directly within an effect"}]}},"fnLoc":null}
+{"kind":"CompileError","detail":{"options":{"category":"Calling setState within an effect can trigger cascading renders","description":"Calling setState directly within a useEffect causes cascading renders that can hurt performance, and is not recommended. Consider alternatives to useEffect. (https://react.dev/learn/you-might-not-need-an-effect)","severity":"InvalidReact","suggestions":null,"details":[{"kind":"error","loc":{"start":{"line":13,"column":4,"index":265},"end":{"line":13,"column":5,"index":266},"filename":"invalid-setState-in-useEffect-transitive.ts","identifierName":"g"},"message":"Avoid calling setState() in the top-level of an effect"}]}},"fnLoc":null}
 {"kind":"CompileSuccess","fnLoc":{"start":{"line":4,"column":0,"index":92},"end":{"line":16,"column":1,"index":293},"filename":"invalid-setState-in-useEffect-transitive.ts"},"fnName":"Component","memoSlots":2,"memoBlocks":2,"memoValues":2,"prunedMemoBlocks":0,"prunedMemoValues":0}
 ```
       

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/invalid-setState-in-useEffect.expect.md

@@ -45,7 +45,7 @@ function _temp(s) {
 ## Logs
 
 ```
-{"kind":"CompileError","detail":{"options":{"category":"Calling setState synchronously within an effect can trigger cascading renders","description":"Effects are intended to synchronize state between React and external systems such as manually updating the DOM, state management libraries, or other platform APIs. In general, the body of an effect should do one or both of the following:\n* Update external systems with the latest state from React.\n* Subscribe for updates from some external system, calling setState in a callback function when external state changes.\n\nCalling setState synchronously within an effect body causes cascading renders that can hurt performance, and is not recommended. (https://react.dev/learn/you-might-not-need-an-effect)","severity":"InvalidReact","suggestions":null,"details":[{"kind":"error","loc":{"start":{"line":7,"column":4,"index":180},"end":{"line":7,"column":12,"index":188},"filename":"invalid-setState-in-useEffect.ts","identifierName":"setState"},"message":"Avoid calling setState() directly within an effect"}]}},"fnLoc":null}
+{"kind":"CompileError","detail":{"options":{"category":"Calling setState within an effect can trigger cascading renders","description":"Calling setState directly within a useEffect causes cascading renders that can hurt performance, and is not recommended. Consider alternatives to useEffect. (https://react.dev/learn/you-might-not-need-an-effect)","severity":"InvalidReact","suggestions":null,"details":[{"kind":"error","loc":{"start":{"line":7,"column":4,"index":180},"end":{"line":7,"column":12,"index":188},"filename":"invalid-setState-in-useEffect.ts","identifierName":"setState"},"message":"Avoid calling setState() in the top-level of an effect"}]}},"fnLoc":null}
 {"kind":"CompileSuccess","fnLoc":{"start":{"line":4,"column":0,"index":92},"end":{"line":10,"column":1,"index":225},"filename":"invalid-setState-in-useEffect.ts"},"fnName":"Component","memoSlots":1,"memoBlocks":1,"memoValues":1,"prunedMemoBlocks":0,"prunedMemoValues":0}
 ```
       

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/preserve-memo-validation/error.maybe-mutable-ref-not-preserved.expect.md

@@ -25,15 +25,13 @@ export const FIXTURE_ENTRYPOINT = {
 ```
 Found 1 error:
 
-Error: Cannot access refs during render
-
-React refs are values that are not needed for rendering. Refs should only be accessed outside of render, such as in event handlers or effects. Accessing a ref value (the `current` property) during render can cause your component not to update as expected (https://react.dev/reference/react/useRef)
+Error: Ref values (the `current` property) may not be accessed during render. (https://react.dev/reference/react/useRef)
 
 error.maybe-mutable-ref-not-preserved.ts:8:33
    6 | function useFoo() {
    7 |   const r = useRef();
 >  8 |   return useMemo(() => makeArray(r), []);
-     |                                  ^ Passing a ref to a function may read its value during render
+     |                                  ^ Ref values (the `current` property) may not be accessed during render. (https://react.dev/reference/react/useRef)
    9 | }
   10 |
   11 | export const FIXTURE_ENTRYPOINT = {

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/preserve-memo-validation/error.useMemo-with-refs.flow.expect.md

@@ -21,14 +21,12 @@ component Component(disableLocalRef, ref) {
 ```
 Found 1 error:
 
-Error: Cannot access refs during render
-
-React refs are values that are not needed for rendering. Refs should only be accessed outside of render, such as in event handlers or effects. Accessing a ref value (the `current` property) during render can cause your component not to update as expected (https://react.dev/reference/react/useRef)
+Error: Ref values (the `current` property) may not be accessed during render. (https://react.dev/reference/react/useRef)
 
    5 |   const localRef = useFooRef();
    6 |   const mergedRef = useMemo(() => {
 >  7 |     return disableLocalRef ? ref : identity(ref, localRef);
-     |                                             ^^^ Passing a ref to a function may read its value during render
+     |                                             ^^^ Ref values (the `current` property) may not be accessed during render. (https://react.dev/reference/react/useRef)
    8 |   }, [disableLocalRef, ref, localRef]);
    9 |   return <div ref={mergedRef} />;
   10 | }

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/preserve-memo-validation/error.validate-useMemo-named-function.expect.md

@@ -24,8 +24,6 @@ Found 1 error:
 
 Error: Expected the first argument to be an inline function expression
 
-Expected the first argument to be an inline function expression
-
 error.validate-useMemo-named-function.ts:9:20
    7 | // for now.
    8 | function Component(props) {

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/reanimated-no-memo-arg.expect.md

@@ -3,7 +3,7 @@
 
 ```javascript
 // @enableCustomTypeDefinitionForReanimated
-import {useAnimatedProps, useSharedValue} from 'react-native-reanimated';
+import {useAnimatedProps} from 'react-native-reanimated';
 function Component() {
   const radius = useSharedValue(50);
 
@@ -39,7 +39,7 @@ export const FIXTURE_ENTRYPOINT = {
 
 ```javascript
 import { c as _c } from "react/compiler-runtime"; // @enableCustomTypeDefinitionForReanimated
-import { useAnimatedProps, useSharedValue } from "react-native-reanimated";
+import { useAnimatedProps } from "react-native-reanimated";
 function Component() {
   const $ = _c(2);
   const radius = useSharedValue(50);

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/reanimated-no-memo-arg.js

@@ -1,5 +1,5 @@
 // @enableCustomTypeDefinitionForReanimated
-import {useAnimatedProps, useSharedValue} from 'react-native-reanimated';
+import {useAnimatedProps} from 'react-native-reanimated';
 function Component() {
   const radius = useSharedValue(50);
 

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/ref-like-name-in-effect.expect.md

@@ -47,32 +47,28 @@ function useCustomRef() {
 function _temp() {}
 
 function Foo() {
-  const $ = _c(4);
+  const $ = _c(3);
   const ref = useCustomRef();
   let t0;
-  if ($[0] !== ref) {
+  let t1;
+  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
     t0 = () => {
       ref.current?.click();
     };
-    $[0] = ref;
-    $[1] = t0;
-  } else {
-    t0 = $[1];
-  }
-  let t1;
-  if ($[2] === Symbol.for("react.memo_cache_sentinel")) {
     t1 = [];
-    $[2] = t1;
+    $[0] = t0;
+    $[1] = t1;
   } else {
-    t1 = $[2];
+    t0 = $[0];
+    t1 = $[1];
   }
   useEffect(t0, t1);
   let t2;
-  if ($[3] === Symbol.for("react.memo_cache_sentinel")) {
+  if ($[2] === Symbol.for("react.memo_cache_sentinel")) {
     t2 = <div>foo</div>;
-    $[3] = t2;
+    $[2] = t2;
   } else {
-    t2 = $[3];
+    t2 = $[2];
   }
   return t2;
 }

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/ref-like-name-in-useCallback-2.expect.md

@@ -14,7 +14,7 @@ function Foo() {
 
   const onClick = useCallback(() => {
     ref.current?.click();
-  }, [ref]);
+  }, []);
 
   return <button onClick={onClick} />;
 }
@@ -47,26 +47,24 @@ function useCustomRef() {
 function _temp() {}
 
 function Foo() {
-  const $ = _c(4);
+  const $ = _c(2);
   const ref = useCustomRef();
   let t0;
-  if ($[0] !== ref) {
+  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
     t0 = () => {
       ref.current?.click();
     };
-    $[0] = ref;
-    $[1] = t0;
+    $[0] = t0;
   } else {
-    t0 = $[1];
+    t0 = $[0];
   }
   const onClick = t0;
   let t1;
-  if ($[2] !== onClick) {
+  if ($[1] === Symbol.for("react.memo_cache_sentinel")) {
     t1 = <button onClick={onClick} />;
-    $[2] = onClick;
-    $[3] = t1;
+    $[1] = t1;
   } else {
-    t1 = $[3];
+    t1 = $[1];
   }
   return t1;
 }

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/ref-like-name-in-useCallback-2.js

@@ -10,7 +10,7 @@ function Foo() {
 
   const onClick = useCallback(() => {
     ref.current?.click();
-  }, [ref]);
+  }, []);
 
   return <button onClick={onClick} />;
 }

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/ref-like-name-in-useCallback.expect.md

@@ -14,7 +14,7 @@ function Foo() {
 
   const onClick = useCallback(() => {
     customRef.current?.click();
-  }, [customRef]);
+  }, []);
 
   return <button onClick={onClick} />;
 }
@@ -47,26 +47,24 @@ function useCustomRef() {
 function _temp() {}
 
 function Foo() {
-  const $ = _c(4);
+  const $ = _c(2);
   const customRef = useCustomRef();
   let t0;
-  if ($[0] !== customRef) {
+  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
     t0 = () => {
       customRef.current?.click();
     };
-    $[0] = customRef;
-    $[1] = t0;
+    $[0] = t0;
   } else {
-    t0 = $[1];
+    t0 = $[0];
   }
   const onClick = t0;
   let t1;
-  if ($[2] !== onClick) {
+  if ($[1] === Symbol.for("react.memo_cache_sentinel")) {
     t1 = <button onClick={onClick} />;
-    $[2] = onClick;
-    $[3] = t1;
+    $[1] = t1;
   } else {
-    t1 = $[3];
+    t1 = $[1];
   }
   return t1;
 }

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/ref-like-name-in-useCallback.js

@@ -10,7 +10,7 @@ function Foo() {
 
   const onClick = useCallback(() => {
     customRef.current?.click();
-  }, [customRef]);
+  }, []);
 
   return <button onClick={onClick} />;
 }

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/repro-mutate-ref-in-function-passed-to-hook.expect.md

@@ -1,114 +0,0 @@
-
-## Input
-
-```javascript
-// @flow
-component Example() {
-  const fooRef = useRef();
-
-  function updateStyles() {
-    const foo = fooRef.current;
-    // The access of `barRef` here before its declaration causes it be hoisted...
-    if (barRef.current == null || foo == null) {
-      return;
-    }
-    foo.style.height = '100px';
-  }
-
-  // ...which previously meant that we didn't infer a type...
-  const barRef = useRef(null);
-
-  const resizeRef = useResizeObserver(
-    rect => {
-      const {width} = rect;
-      // ...which meant that we failed to ignore the mutation here...
-      barRef.current = width;
-    } // ...which caused this to fail with "can't freeze a mutable function"
-  );
-
-  useLayoutEffect(() => {
-    const observer = new ResizeObserver(_ => {
-      updateStyles();
-    });
-
-    return () => {
-      observer.disconnect();
-    };
-  }, []);
-
-  return <div ref={resizeRef} />;
-}
-
-```
-
-## Code
-
-```javascript
-import { c as _c } from "react/compiler-runtime";
-function Example() {
-  const $ = _c(6);
-  const fooRef = useRef();
-  let t0;
-  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
-    t0 = function updateStyles() {
-      const foo = fooRef.current;
-      if (barRef.current == null || foo == null) {
-        return;
-      }
-
-      foo.style.height = "100px";
-    };
-    $[0] = t0;
-  } else {
-    t0 = $[0];
-  }
-  const updateStyles = t0;
-
-  const barRef = useRef(null);
-  let t1;
-  if ($[1] === Symbol.for("react.memo_cache_sentinel")) {
-    t1 = (rect) => {
-      const { width } = rect;
-
-      barRef.current = width;
-    };
-    $[1] = t1;
-  } else {
-    t1 = $[1];
-  }
-  const resizeRef = useResizeObserver(t1);
-  let t2;
-  let t3;
-  if ($[2] === Symbol.for("react.memo_cache_sentinel")) {
-    t2 = () => {
-      const observer = new ResizeObserver((_) => {
-        updateStyles();
-      });
-      return () => {
-        observer.disconnect();
-      };
-    };
-
-    t3 = [];
-    $[2] = t2;
-    $[3] = t3;
-  } else {
-    t2 = $[2];
-    t3 = $[3];
-  }
-  useLayoutEffect(t2, t3);
-  let t4;
-  if ($[4] !== resizeRef) {
-    t4 = <div ref={resizeRef} />;
-    $[4] = resizeRef;
-    $[5] = t4;
-  } else {
-    t4 = $[5];
-  }
-  return t4;
-}
-
-```
-      
-### Eval output
-(kind: exception) Fixture not implemented

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/repro-mutate-ref-in-function-passed-to-hook.js

@@ -1,36 +0,0 @@
-// @flow
-component Example() {
-  const fooRef = useRef();
-
-  function updateStyles() {
-    const foo = fooRef.current;
-    // The access of `barRef` here before its declaration causes it be hoisted...
-    if (barRef.current == null || foo == null) {
-      return;
-    }
-    foo.style.height = '100px';
-  }
-
-  // ...which previously meant that we didn't infer a type...
-  const barRef = useRef(null);
-
-  const resizeRef = useResizeObserver(
-    rect => {
-      const {width} = rect;
-      // ...which meant that we failed to ignore the mutation here...
-      barRef.current = width;
-    } // ...which caused this to fail with "can't freeze a mutable function"
-  );
-
-  useLayoutEffect(() => {
-    const observer = new ResizeObserver(_ => {
-      updateStyles();
-    });
-
-    return () => {
-      observer.disconnect();
-    };
-  }, []);
-
-  return <div ref={resizeRef} />;
-}

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/repro-mutate-result-of-function-call-with-frozen-argument-in-function-expression.expect.md

@@ -1,77 +0,0 @@
-
-## Input
-
-```javascript
-import {identity, makeObject_Primitives, Stringify} from 'shared-runtime';
-
-function Example(props) {
-  const object = props.object;
-  const f = () => {
-    // The argument maybe-aliases into the return
-    const obj = identity(object);
-    obj.property = props.value;
-    return obj;
-  };
-  const obj = f();
-  return <Stringify obj={obj} />;
-}
-
-export const FIXTURE_ENTRYPOINT = {
-  fn: Example,
-  params: [{object: makeObject_Primitives(), value: 42}],
-};
-
-```
-
-## Code
-
-```javascript
-import { c as _c } from "react/compiler-runtime";
-import { identity, makeObject_Primitives, Stringify } from "shared-runtime";
-
-function Example(props) {
-  const $ = _c(7);
-  const object = props.object;
-  let t0;
-  if ($[0] !== object || $[1] !== props.value) {
-    t0 = () => {
-      const obj = identity(object);
-      obj.property = props.value;
-      return obj;
-    };
-    $[0] = object;
-    $[1] = props.value;
-    $[2] = t0;
-  } else {
-    t0 = $[2];
-  }
-  const f = t0;
-  let t1;
-  if ($[3] !== f) {
-    t1 = f();
-    $[3] = f;
-    $[4] = t1;
-  } else {
-    t1 = $[4];
-  }
-  const obj_0 = t1;
-  let t2;
-  if ($[5] !== obj_0) {
-    t2 = <Stringify obj={obj_0} />;
-    $[5] = obj_0;
-    $[6] = t2;
-  } else {
-    t2 = $[6];
-  }
-  return t2;
-}
-
-export const FIXTURE_ENTRYPOINT = {
-  fn: Example,
-  params: [{ object: makeObject_Primitives(), value: 42 }],
-};
-
-```
-      
-### Eval output
-(kind: ok) <div>{"obj":{"a":0,"b":"value1","c":true,"property":42}}</div>

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/repro-mutate-result-of-function-call-with-frozen-argument-in-function-expression.js

@@ -1,18 +0,0 @@
-import {identity, makeObject_Primitives, Stringify} from 'shared-runtime';
-
-function Example(props) {
-  const object = props.object;
-  const f = () => {
-    // The argument maybe-aliases into the return
-    const obj = identity(object);
-    obj.property = props.value;
-    return obj;
-  };
-  const obj = f();
-  return <Stringify obj={obj} />;
-}
-
-export const FIXTURE_ENTRYPOINT = {
-  fn: Example,
-  params: [{object: makeObject_Primitives(), value: 42}],
-};

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/repro-mutate-result-of-method-call-on-frozen-value-in-function-expression.expect.md

@@ -1,77 +0,0 @@
-
-## Input
-
-```javascript
-import {makeObject_Primitives, Stringify} from 'shared-runtime';
-
-function Example(props) {
-  const object = props.object;
-  const f = () => {
-    // The receiver maybe-aliases into the return
-    const obj = object.makeObject();
-    obj.property = props.value;
-    return obj;
-  };
-  const obj = f();
-  return <Stringify obj={obj} />;
-}
-
-export const FIXTURE_ENTRYPOINT = {
-  fn: Example,
-  params: [{object: {makeObject: makeObject_Primitives}, value: 42}],
-};
-
-```
-
-## Code
-
-```javascript
-import { c as _c } from "react/compiler-runtime";
-import { makeObject_Primitives, Stringify } from "shared-runtime";
-
-function Example(props) {
-  const $ = _c(7);
-  const object = props.object;
-  let t0;
-  if ($[0] !== object || $[1] !== props.value) {
-    t0 = () => {
-      const obj = object.makeObject();
-      obj.property = props.value;
-      return obj;
-    };
-    $[0] = object;
-    $[1] = props.value;
-    $[2] = t0;
-  } else {
-    t0 = $[2];
-  }
-  const f = t0;
-  let t1;
-  if ($[3] !== f) {
-    t1 = f();
-    $[3] = f;
-    $[4] = t1;
-  } else {
-    t1 = $[4];
-  }
-  const obj_0 = t1;
-  let t2;
-  if ($[5] !== obj_0) {
-    t2 = <Stringify obj={obj_0} />;
-    $[5] = obj_0;
-    $[6] = t2;
-  } else {
-    t2 = $[6];
-  }
-  return t2;
-}
-
-export const FIXTURE_ENTRYPOINT = {
-  fn: Example,
-  params: [{ object: { makeObject: makeObject_Primitives }, value: 42 }],
-};
-
-```
-      
-### Eval output
-(kind: ok) <div>{"obj":{"a":0,"b":"value1","c":true,"property":42}}</div>

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/repro-mutate-result-of-method-call-on-frozen-value-in-function-expression.js

@@ -1,18 +0,0 @@
-import {makeObject_Primitives, Stringify} from 'shared-runtime';
-
-function Example(props) {
-  const object = props.object;
-  const f = () => {
-    // The receiver maybe-aliases into the return
-    const obj = object.makeObject();
-    obj.property = props.value;
-    return obj;
-  };
-  const obj = f();
-  return <Stringify obj={obj} />;
-}
-
-export const FIXTURE_ENTRYPOINT = {
-  fn: Example,
-  params: [{object: {makeObject: makeObject_Primitives}, value: 42}],
-};

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/repro-mutate-result-of-method-call-on-frozen-value-is-allowed.expect.md

@@ -1,57 +0,0 @@
-
-## Input
-
-```javascript
-import {makeObject_Primitives, Stringify} from 'shared-runtime';
-
-function Example(props) {
-  const obj = props.object.makeObject();
-  obj.property = props.value;
-  return <Stringify obj={obj} />;
-}
-
-export const FIXTURE_ENTRYPOINT = {
-  fn: Example,
-  params: [{object: {makeObject: makeObject_Primitives}, value: 42}],
-};
-
-```
-
-## Code
-
-```javascript
-import { c as _c } from "react/compiler-runtime";
-import { makeObject_Primitives, Stringify } from "shared-runtime";
-
-function Example(props) {
-  const $ = _c(5);
-  let obj;
-  if ($[0] !== props.object || $[1] !== props.value) {
-    obj = props.object.makeObject();
-    obj.property = props.value;
-    $[0] = props.object;
-    $[1] = props.value;
-    $[2] = obj;
-  } else {
-    obj = $[2];
-  }
-  let t0;
-  if ($[3] !== obj) {
-    t0 = <Stringify obj={obj} />;
-    $[3] = obj;
-    $[4] = t0;
-  } else {
-    t0 = $[4];
-  }
-  return t0;
-}
-
-export const FIXTURE_ENTRYPOINT = {
-  fn: Example,
-  params: [{ object: { makeObject: makeObject_Primitives }, value: 42 }],
-};
-
-```
-      
-### Eval output
-(kind: ok) <div>{"obj":{"a":0,"b":"value1","c":true,"property":42}}</div>

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/repro-mutate-result-of-method-call-on-frozen-value-is-allowed.js

@@ -1,12 +0,0 @@
-import {makeObject_Primitives, Stringify} from 'shared-runtime';
-
-function Example(props) {
-  const obj = props.object.makeObject();
-  obj.property = props.value;
-  return <Stringify obj={obj} />;
-}
-
-export const FIXTURE_ENTRYPOINT = {
-  fn: Example,
-  params: [{object: {makeObject: makeObject_Primitives}, value: 42}],
-};

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/useMemo-arrow-implicit-return.expect.md

@@ -1,40 +0,0 @@
-
-## Input
-
-```javascript
-// @validateNoVoidUseMemo
-function Component() {
-  const value = useMemo(() => computeValue(), []);
-  return <div>{value}</div>;
-}
-
-```
-
-## Code
-
-```javascript
-import { c as _c } from "react/compiler-runtime"; // @validateNoVoidUseMemo
-function Component() {
-  const $ = _c(2);
-  let t0;
-  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
-    t0 = computeValue();
-    $[0] = t0;
-  } else {
-    t0 = $[0];
-  }
-  const value = t0;
-  let t1;
-  if ($[1] === Symbol.for("react.memo_cache_sentinel")) {
-    t1 = <div>{value}</div>;
-    $[1] = t1;
-  } else {
-    t1 = $[1];
-  }
-  return t1;
-}
-
-```
-      
-### Eval output
-(kind: exception) Fixture not implemented