[compiler] Aggregate error reporting, separate eslint rules

NOTE: this is a merged version of @mofeiZ's original PR along with my edits per offline discussion. The description is updated to reflect the latest approach.

The key problem we're trying to solve with this PR is to allow developers more control over the compiler's various validations. The idea is to have a number of rules targeting a specific category of issues, such as enforcing immutability of props/state/etc or disallowing access to refs during render. We don't want to have to run the compiler again for every single rule, though, so @mofeiZ added an LRU cache that caches the full compilation output of N most recent files. The first rule to run on a given file will cause it to get cached, and then subsequent rules can pull from the cache, with each rule filtering down to its specific category of errors.

For the categories, I went through and assigned a category roughly 1:1 to existing validations, and then used my judgement on some places that felt distinct enough to warrant a separate error. Every error in the compiler now has to supply both a severity (for legacy reasons) and a category (for ESLint). Each category corresponds 1:1 to a ESLint rule definition, so that the set of rules is automatically populated based on the defined categories.

Categories include a flag for whether they should be in the recommended set or not.

Note that as with the original version of this PR, only eslint-plugin-react-compiler is changed. We still have to update the main lint rule.

.eslintrc.js

@@ -468,6 +468,7 @@ module.exports = {
       files: ['packages/react-server-dom-webpack/**/*.js'],
       globals: {
         __webpack_chunk_load__: 'readonly',
+        __webpack_get_script_filename__: 'readonly',
         __webpack_require__: 'readonly',
       },
     },

babel.config-ts.js

@@ -8,6 +8,7 @@ module.exports = {
     '@babel/plugin-syntax-jsx',
     '@babel/plugin-transform-flow-strip-types',
     ['@babel/plugin-transform-class-properties', {loose: true}],
+    ['@babel/plugin-transform-private-methods', {loose: true}],
     '@babel/plugin-transform-classes',
   ],
   presets: [

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

@@ -10,33 +10,64 @@ import {codeFrameColumns} from '@babel/code-frame';
 import type {SourceLocation} from './HIR';
 import {Err, Ok, Result} from './Utils/Result';
 import {assertExhaustive} from './Utils/utils';
-import {ErrorSeverity} from './Utils/CompilerErrorSeverity';
-import {
-  ErrorCode,
-  ErrorCodeDetails,
-  LinterCategory,
-} from './Utils/CompilerErrorCodes';
-export {ErrorSeverity};
-export {ErrorCode, ErrorCodeDetails, LinterCategory};
+
+export enum ErrorSeverity {
+  /**
+   * Invalid JS syntax, or valid syntax that is semantically invalid which may indicate some
+   * misunderstanding on the user’s part.
+   */
+  InvalidJS = 'InvalidJS',
+  /**
+   * JS syntax that is not supported and which we do not plan to support. Developers should
+   * rewrite to use supported forms.
+   */
+  UnsupportedJS = 'UnsupportedJS',
+  /**
+   * Code that breaks the rules of React.
+   */
+  InvalidReact = 'InvalidReact',
+  /**
+   * Incorrect configuration of the compiler.
+   */
+  InvalidConfig = 'InvalidConfig',
+  /**
+   * Code that can reasonably occur and that doesn't break any rules, but is unsafe to preserve
+   * memoization.
+   */
+  CannotPreserveMemoization = 'CannotPreserveMemoization',
+  /**
+   * Unhandled syntax that we don't support yet.
+   */
+  Todo = 'Todo',
+  /**
+   * An unexpected internal error in the compiler that indicates critical issues that can panic
+   * the compiler.
+   */
+  Invariant = 'Invariant',
+}
 
 export type CompilerDiagnosticOptions = {
+  category: ErrorCategory;
   severity: ErrorSeverity;
-  category: string;
-  description?: string | null | undefined;
+  reason: string;
+  description: string;
   details: Array<CompilerDiagnosticDetail>;
   suggestions?: Array<CompilerSuggestion> | null | undefined;
-  linterCategory?: LinterCategory | null | undefined;
 };
 
 export type CompilerDiagnosticDetail =
   /**
    * A/the source of the error
    */
-  {
-    kind: 'error';
-    loc: SourceLocation | null;
-    message: string;
-  };
+  | {
+      kind: 'error';
+      loc: SourceLocation | null;
+      message: string;
+    }
+  | {
+      kind: 'hint';
+      message: string;
+    };
 
 export enum CompilerSuggestionOperation {
   InsertBefore,
@@ -60,28 +91,14 @@ export type CompilerSuggestion =
       description: string;
     };
 
-export type PlainCompilerErrorDetailOptions = {
-  errorCode?: void;
+export type CompilerErrorDetailOptions = {
+  category: ErrorCategory;
+  severity: ErrorSeverity;
   reason: string;
   description?: string | null | undefined;
-  severity:
-    | ErrorSeverity.Invariant
-    | ErrorSeverity.Todo
-    | ErrorSeverity.InvalidConfig;
   loc: SourceLocation | null;
   suggestions?: Array<CompilerSuggestion> | null | undefined;
 };
-export type CodedCompilerErrorDetailOptions = {
-  errorCode: ErrorCode;
-  description?: string | null | undefined;
-  loc: SourceLocation | null;
-  suggestions?: Array<CompilerSuggestion> | null | undefined;
-  linterCategory?: LinterCategory | null | undefined;
-};
-
-export type CompilerErrorDetailOptions =
-  | PlainCompilerErrorDetailOptions
-  | CodedCompilerErrorDetailOptions;
 
 export type PrintErrorMessageOptions = {
   /**
@@ -91,74 +108,21 @@ export type PrintErrorMessageOptions = {
   eslint: boolean;
 };
 
-export function makeCompilerDiagnostic(
-  code: ErrorCode,
-  options?: {
-    description?: string;
-    suggestions?: Array<CompilerSuggestion> | null | undefined;
-  },
-): CompilerDiagnostic {
-  return makeCompilerDiagnostic(code, options);
-}
-
 export class CompilerDiagnostic {
   options: CompilerDiagnosticOptions;
 
-  /**
-   * Constructor is private to enforce that we either only create invariant diagnostics
-   * or use ErrorCodes
-   */
-  private constructor(options: CompilerDiagnosticOptions) {
+  constructor(options: CompilerDiagnosticOptions) {
     this.options = options;
   }
 
-  static create<
-    T extends CompilerDiagnosticOptions & {severity: ErrorSeverity.Invariant},
-  >(options: Omit<T, 'details'>): CompilerDiagnostic {
+  static create(
+    options: Omit<CompilerDiagnosticOptions, 'details'>,
+  ): CompilerDiagnostic {
     return new CompilerDiagnostic({...options, details: []});
   }
 
-  static fromCode(
-    code: ErrorCode,
-    options?: {
-      description?: string;
-      suggestions?: Array<CompilerSuggestion> | null | undefined;
-      details?: Array<CompilerDiagnosticDetail> | null | undefined;
-    },
-  ): CompilerDiagnostic {
-    const errorEntry = ErrorCodeDetails[code];
-    let description = undefined;
-    if (errorEntry.description != null) {
-      description = endWithPeriod(errorEntry.description);
-    }
-    if (options?.description != null && options.description.length > 0) {
-      if (description != null && description.length > 0) {
-        description += ' ';
-      } else {
-        description = '';
-      }
-      description += endWithPeriod(options.description);
-    }
-
-    const diagnosticOptions: CompilerDiagnosticOptions = {
-      severity: errorEntry.severity,
-      category: errorEntry.reason,
-      description,
-      linterCategory: errorEntry.linterCategory,
-      suggestions: options?.suggestions,
-      details: options?.details ?? [],
-    };
-
-    return new CompilerDiagnostic(diagnosticOptions);
-  }
-
-  // TODO: remove after converting test fixtures to use printErrorMessage
-  serialize(): unknown {
-    return {options: {...this.options, linterCategory: undefined}};
-  }
-
-  get category(): CompilerDiagnosticOptions['category'] {
-    return this.options.category;
+  get reason(): CompilerDiagnosticOptions['reason'] {
+    return this.options.reason;
   }
   get description(): CompilerDiagnosticOptions['description'] {
     return this.options.description;
@@ -169,8 +133,8 @@ export class CompilerDiagnostic {
   get suggestions(): CompilerDiagnosticOptions['suggestions'] {
     return this.options.suggestions;
   }
-  get linterCategory(): CompilerDiagnosticOptions['linterCategory'] {
-    return this.options.linterCategory;
+  get category(): ErrorCategory {
+    return this.options.category;
   }
 
   withDetail(detail: CompilerDiagnosticDetail): CompilerDiagnostic {
@@ -179,14 +143,20 @@ export class CompilerDiagnostic {
   }
 
   primaryLocation(): SourceLocation | null {
-    return this.options.details.filter(d => d.kind === 'error')[0]?.loc ?? null;
+    const firstErrorDetail = this.options.details.filter(
+      d => d.kind === 'error',
+    )[0];
+    return firstErrorDetail != null && firstErrorDetail.kind === 'error'
+      ? firstErrorDetail.loc
+      : null;
   }
 
   printErrorMessage(source: string, options: PrintErrorMessageOptions): string {
-    const buffer = [printErrorSummary(this.severity, this.category)];
-    if (this.description != null) {
-      buffer.push(`\n\n${endWithPeriod(this.description)}`);
-    }
+    const buffer = [
+      printErrorSummary(this.severity, this.reason),
+      '\n\n',
+      this.description,
+    ];
     for (const detail of this.options.details) {
       switch (detail.kind) {
         case 'error': {
@@ -211,9 +181,14 @@ export class CompilerDiagnostic {
           buffer.push(codeFrame);
           break;
         }
+        case 'hint': {
+          buffer.push('\n\n');
+          buffer.push(detail.message);
+          break;
+        }
         default: {
           assertExhaustive(
-            detail.kind,
+            detail,
             `Unexpected detail kind ${(detail as any).kind}`,
           );
         }
@@ -223,9 +198,9 @@ export class CompilerDiagnostic {
   }
 
   toString(): string {
-    const buffer = [printErrorSummary(this.severity, this.category)];
+    const buffer = [printErrorSummary(this.severity, this.reason)];
     if (this.description != null) {
-      buffer.push(`. ${endWithPeriod(this.description)}`);
+      buffer.push(`. ${this.description}.`);
     }
     const loc = this.primaryLocation();
     if (loc != null && typeof loc !== 'symbol') {
@@ -246,68 +221,13 @@ export class CompilerErrorDetail {
     this.options = options;
   }
 
-  static fromCode(
-    code: ErrorCode,
-    details?: {
-      description?: string | null;
-      loc?: SourceLocation | null;
-      suggestions?: Array<CompilerSuggestion> | null | undefined;
-    },
-  ): CompilerErrorDetail {
-    return new CompilerErrorDetail({
-      ...details,
-      errorCode: code,
-    } as CodedCompilerErrorDetailOptions);
+  get reason(): CompilerErrorDetailOptions['reason'] {
+    return this.options.reason;
   }
-
-  // TODO: remove after converting test fixtures to use printErrorMessage
-  serialize(): unknown {
-    return {
-      options: {
-        reason: this.reason,
-        description: this.description,
-        severity: this.severity,
-        loc: this.loc,
-        suggestions: this.suggestions,
-      },
-    };
+  get description(): CompilerErrorDetailOptions['description'] {
+    return this.options.description;
   }
-
-  get reason(): string {
-    if (this.options.errorCode != null) {
-      return ErrorCodeDetails[this.options.errorCode].reason;
-    } else {
-      return this.options.reason;
-    }
-  }
-  get description(): string | null | undefined {
-    if (this.options.errorCode != null) {
-      let description = undefined;
-      const errorEntry = ErrorCodeDetails[this.options.errorCode];
-      if (errorEntry.description != null) {
-        description = endWithPeriod(errorEntry.description);
-      }
-      if (
-        this.options.description != null &&
-        this.options.description.length > 0
-      ) {
-        if (description != null && description.length > 0) {
-          description += ' ';
-        } else {
-          description = '';
-        }
-        description += endWithPeriod(this.options.description);
-      }
-      return description;
-    }
-    return this.options.description != null
-      ? endWithPeriod(this.options.description)
-      : this.options.description;
-  }
-  get severity(): ErrorSeverity {
-    if (this.options.errorCode != null) {
-      return ErrorCodeDetails[this.options.errorCode].severity;
-    }
+  get severity(): CompilerErrorDetailOptions['severity'] {
     return this.options.severity;
   }
   get loc(): CompilerErrorDetailOptions['loc'] {
@@ -316,11 +236,8 @@ export class CompilerErrorDetail {
   get suggestions(): CompilerErrorDetailOptions['suggestions'] {
     return this.options.suggestions;
   }
-  get linterCategory(): LinterCategory | null | undefined {
-    if (this.options.errorCode != null) {
-      return ErrorCodeDetails[this.options.errorCode].linterCategory;
-    }
-    return undefined;
+  get category(): ErrorCategory {
+    return this.options.category;
   }
 
   primaryLocation(): SourceLocation | null {
@@ -330,7 +247,7 @@ export class CompilerErrorDetail {
   printErrorMessage(source: string, options: PrintErrorMessageOptions): string {
     const buffer = [printErrorSummary(this.severity, this.reason)];
     if (this.description != null) {
-      buffer.push(`\n\n${endWithPeriod(this.description)}`);
+      buffer.push(`\n\n${this.description}.`);
     }
     const loc = this.loc;
     if (loc != null && typeof loc !== 'symbol') {
@@ -355,7 +272,7 @@ export class CompilerErrorDetail {
   toString(): string {
     const buffer = [printErrorSummary(this.severity, this.reason)];
     if (this.description != null) {
-      buffer.push(`. ${endWithPeriod(this.description)}`);
+      buffer.push(`. ${this.description}.`);
     }
     const loc = this.loc;
     if (loc != null && typeof loc !== 'symbol') {
@@ -371,13 +288,14 @@ export class CompilerError extends Error {
 
   static invariant(
     condition: unknown,
-    options: Omit<PlainCompilerErrorDetailOptions, 'severity'>,
+    options: Omit<CompilerErrorDetailOptions, 'severity' | 'category'>,
   ): asserts condition {
     if (!condition) {
       const errors = new CompilerError();
       errors.pushErrorDetail(
         new CompilerErrorDetail({
           ...options,
+          category: ErrorCategory.Invariant,
           severity: ErrorSeverity.Invariant,
         }),
       );
@@ -385,43 +303,62 @@ export class CompilerError extends Error {
     }
   }
 
-  static throwDiagnostic(diagnostic: CompilerDiagnostic): never {
+  static throwDiagnostic(options: CompilerDiagnosticOptions): never {
     const errors = new CompilerError();
-    errors.pushDiagnostic(diagnostic);
+    errors.pushDiagnostic(new CompilerDiagnostic(options));
     throw errors;
   }
 
   static throwTodo(
-    options: Omit<PlainCompilerErrorDetailOptions, 'severity'>,
+    options: Omit<CompilerErrorDetailOptions, 'severity' | 'category'>,
   ): never {
     const errors = new CompilerError();
     errors.pushErrorDetail(
-      new CompilerErrorDetail({...options, severity: ErrorSeverity.Todo}),
+      new CompilerErrorDetail({
+        ...options,
+        severity: ErrorSeverity.Todo,
+        category: ErrorCategory.Todo,
+      }),
     );
     throw errors;
   }
 
-  static throwFromCode(
-    code: ErrorCode,
-    options?: {
-      description?: string | null;
-      loc?: SourceLocation | null;
-      suggestions?: Array<CompilerSuggestion> | null | undefined;
-    },
+  static throwInvalidJS(
+    options: Omit<CompilerErrorDetailOptions, 'severity' | 'category'>,
   ): never {
     const errors = new CompilerError();
-    errors.pushErrorDetail(CompilerErrorDetail.fromCode(code, options));
+    errors.pushErrorDetail(
+      new CompilerErrorDetail({
+        ...options,
+        severity: ErrorSeverity.InvalidJS,
+        category: ErrorCategory.Syntax,
+      }),
+    );
+    throw errors;
+  }
+
+  static throwInvalidReact(
+    options: Omit<CompilerErrorDetailOptions, 'severity'>,
+  ): never {
+    const errors = new CompilerError();
+    errors.pushErrorDetail(
+      new CompilerErrorDetail({
+        ...options,
+        severity: ErrorSeverity.InvalidReact,
+      }),
+    );
     throw errors;
   }
 
   static throwInvalidConfig(
-    options: Omit<PlainCompilerErrorDetailOptions, 'severity'>,
+    options: Omit<CompilerErrorDetailOptions, 'severity' | 'category'>,
   ): never {
     const errors = new CompilerError();
     errors.pushErrorDetail(
       new CompilerErrorDetail({
         ...options,
         severity: ErrorSeverity.InvalidConfig,
+        category: ErrorCategory.Config,
       }),
     );
     throw errors;
@@ -484,10 +421,14 @@ export class CompilerError extends Error {
   }
 
   push(options: CompilerErrorDetailOptions): CompilerErrorDetail {
-    if (options instanceof CompilerErrorDetail) {
-      return this.pushErrorDetail(options);
-    }
-    const detail = new CompilerErrorDetail(options);
+    const detail = new CompilerErrorDetail({
+      category: options.category,
+      reason: options.reason,
+      description: options.description ?? null,
+      severity: options.severity,
+      suggestions: options.suggestions,
+      loc: typeof options.loc === 'symbol' ? null : options.loc,
+    });
     return this.pushErrorDetail(detail);
   }
 
@@ -496,19 +437,6 @@ export class CompilerError extends Error {
     return detail;
   }
 
-  pushErrorCode(
-    code: ErrorCode,
-    details?: {
-      description?: string | null;
-      loc?: SourceLocation | null;
-      suggestions?: Array<CompilerSuggestion> | null | undefined;
-    },
-  ): CompilerErrorDetail {
-    const detail = CompilerErrorDetail.fromCode(code, details);
-    this.details.push(detail);
-    return detail;
-  }
-
   hasErrors(): boolean {
     return this.details.length > 0;
   }
@@ -596,9 +524,321 @@ function printErrorSummary(severity: ErrorSeverity, message: string): string {
   return `${severityCategory}: ${message}`;
 }
 
-function endWithPeriod(s: string): string {
-  if (s === '' || s.endsWith('.')) {
-    return s;
-  }
-  return `${s.replace(/\.+$/, '')}.`;
+/**
+ * See getRuleForCategory() for how these map to ESLint rules
+ */
+export enum ErrorCategory {
+  // Checking for valid hooks usage (non conditional, non-first class, non reactive, etc)
+  Hooks = 'Hooks',
+
+  // Checking for no capitalized calls (not definitively an error, hence separating)
+  CapitalizedCalls = 'CapitalizedCalls',
+
+  // Checking for static components
+  StaticComponents = 'StaticComponents',
+
+  // Checking for valid usage of manual memoization
+  UseMemo = 'UseMemo',
+
+  // Checks that manual memoization is preserved
+  PreserveManualMemo = 'PreserveManualMemo',
+
+  // Checking for no mutations of props, hook arguments, hook return values
+  Immutability = 'Immutability',
+
+  // Checking for assignments to globals
+  Globals = 'Globals',
+
+  // Checking for valid usage of refs, ie no access during render
+  Refs = 'Refs',
+
+  // Checks for memoized effect deps
+  EffectDependencies = 'EffectDependencies',
+
+  // Checks for no setState in effect bodies
+  EffectSetState = 'EffectSetState',
+
+  EffectDerivationsOfState = 'EffectDerivationsOfState',
+
+  // Validates against try/catch in place of error boundaries
+  ErrorBoundaries = 'ErrorBoundaries',
+
+  // Checking for pure functions
+  Purity = 'Purity',
+
+  // Validates against setState in render
+  RenderSetState = 'RenderSetState',
+
+  // Internal invariants
+  Invariant = 'Invariant',
+
+  // Todos
+  Todo = 'Todo',
+
+  // Syntax errors
+  Syntax = 'Syntax',
+
+  // Checks for use of unsupported syntax
+  UnsupportedSyntax = 'UnsupportedSyntax',
+
+  // Config errors
+  Config = 'Config',
+
+  // Gating error
+  Gating = 'Gating',
+
+  // Suppressions
+  Suppression = 'Suppression',
+
+  // Issues with auto deps
+  AutomaticEffectDependencies = 'AutomaticEffectDependencies',
+
+  // Issues with `fire`
+  Fire = 'Fire',
+
+  // fbt-specific issues
+  FBT = 'FBT',
 }
+
+export type LintRule = {
+  // Stores the category the rule corresponds to, used to filter errors when reporting
+  category: ErrorCategory;
+
+  /**
+   * The "name" of the rule as it will be used by developers to enable/disable, eg
+   * "eslint-disable-nest line <name>"
+   */
+  name: string;
+
+  /**
+   * A description of the rule that appears somewhere in ESLint. This does not affect
+   * how error messages are formatted
+   */
+  description: string;
+
+  /**
+   * If true, this rule will automatically appear in the default, "recommended" ESLint
+   * rule set. Otherwise it will be part of an `allRules` export that developers can
+   * use to opt-in to showing output of all possible rules.
+   *
+   * NOTE: not all validations are enabled by default! Setting this flag only affects
+   * whether a given rule is part of the recommended set. The corresponding validation
+   * also should be enabled by default if you want the error to actually show up!
+   */
+  recommended: boolean;
+};
+
+export function getRuleForCategory(category: ErrorCategory): LintRule {
+  switch (category) {
+    case ErrorCategory.AutomaticEffectDependencies: {
+      return {
+        category,
+        name: 'automatic-effect-dependencies',
+        description:
+          'Verifies that automatic effect dependencies are compiled if opted-in',
+        recommended: true,
+      };
+    }
+    case ErrorCategory.CapitalizedCalls: {
+      return {
+        category,
+        name: 'capitalized-calls',
+        description:
+          'Validates against calling capitalized functions/methods instead of using JSX',
+        recommended: false,
+      };
+    }
+    case ErrorCategory.Config: {
+      return {
+        category,
+        name: 'config',
+        description: 'Validates the configuration',
+        recommended: true,
+      };
+    }
+    case ErrorCategory.EffectDependencies: {
+      return {
+        category,
+        name: 'memoized-effect-dependencies',
+        description: 'Validates that effect dependencies are memoized',
+        recommended: false,
+      };
+    }
+    case ErrorCategory.EffectDerivationsOfState: {
+      return {
+        category,
+        name: 'no-deriving-state-in-effects',
+        description:
+          'Validates against deriving values from state in an effect',
+        recommended: false,
+      };
+    }
+    case ErrorCategory.EffectSetState: {
+      return {
+        category,
+        name: 'set-state-in-effect',
+        description:
+          'Validates against calling setState synchronously in an effect',
+        recommended: true,
+      };
+    }
+    case ErrorCategory.ErrorBoundaries: {
+      return {
+        category,
+        name: 'error-boundaries',
+        description:
+          'Validates usage of error boundaries instead of try/catch for errors in JSX',
+        recommended: true,
+      };
+    }
+    case ErrorCategory.FBT: {
+      return {
+        category,
+        name: 'fbt',
+        description: 'Validates usage of fbt',
+        recommended: false,
+      };
+    }
+    case ErrorCategory.Fire: {
+      return {
+        category,
+        name: 'fire',
+        description: 'Validates usage of `fire`',
+        recommended: false,
+      };
+    }
+    case ErrorCategory.Gating: {
+      return {
+        category,
+        name: 'gating',
+        description: 'Validates configuration of gating mode',
+        recommended: true,
+      };
+    }
+    case ErrorCategory.Globals: {
+      return {
+        category,
+        name: 'globals',
+        description:
+          'Validates against assignment/mutation of globals during render',
+        recommended: true,
+      };
+    }
+    case ErrorCategory.Hooks: {
+      return {
+        category,
+        name: 'hooks',
+        description: 'Validates the rules of hooks',
+        recommended: true,
+      };
+    }
+    case ErrorCategory.Immutability: {
+      return {
+        category,
+        name: 'immutability',
+        description:
+          'Validates that immutable values (props, state, etc) are not mutated',
+        recommended: true,
+      };
+    }
+    case ErrorCategory.Invariant: {
+      return {
+        category,
+        name: 'invariant',
+        description: 'Internal invariants',
+        recommended: false,
+      };
+    }
+    case ErrorCategory.PreserveManualMemo: {
+      return {
+        category,
+        name: 'preserve-manual-memoization',
+        description:
+          'Validates that existing manual memoized is preserved by the compiler',
+        recommended: true,
+      };
+    }
+    case ErrorCategory.Purity: {
+      return {
+        category,
+        name: 'purity',
+        description:
+          'Validates that the component/hook is pure, and does not call known-impure functions',
+        recommended: true,
+      };
+    }
+    case ErrorCategory.Refs: {
+      return {
+        category,
+        name: 'refs',
+        description:
+          'Validates correct usage of refs, not reading/writing during render',
+        recommended: true,
+      };
+    }
+    case ErrorCategory.RenderSetState: {
+      return {
+        category,
+        name: 'set-state-in-render',
+        description: 'Validates against setting state during render',
+        recommended: true,
+      };
+    }
+    case ErrorCategory.StaticComponents: {
+      return {
+        category,
+        name: 'static-components',
+        description:
+          'Validates that components are static, not recreated every render',
+        recommended: true,
+      };
+    }
+    case ErrorCategory.Suppression: {
+      return {
+        category,
+        name: 'rule-suppression',
+        description: 'Validates against suppression of other rules',
+        recommended: false,
+      };
+    }
+    case ErrorCategory.Syntax: {
+      return {
+        category,
+        name: 'syntax',
+        description: 'Validates against invalid syntax',
+        recommended: false,
+      };
+    }
+    case ErrorCategory.Todo: {
+      return {
+        category,
+        name: 'todo',
+        description: 'Unimplemented features',
+        recommended: false,
+      };
+    }
+    case ErrorCategory.UnsupportedSyntax: {
+      return {
+        category,
+        name: 'unsupported-syntax',
+        description: 'Validates against syntax that we do not plan to support',
+        recommended: true,
+      };
+    }
+    case ErrorCategory.UseMemo: {
+      return {
+        category,
+        name: 'use-memo',
+        description: 'Validates usage of the useMemo() hook',
+        recommended: true,
+      };
+    }
+    default: {
+      assertExhaustive(category, `Unsupported category ${category}`);
+    }
+  }
+}
+
+export const LintRules: Array<LintRule> = Object.keys(ErrorCategory).map(
+  category => getRuleForCategory(category as any),
+);

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

@@ -9,7 +9,7 @@ import {NodePath} from '@babel/core';
 import * as t from '@babel/types';
 import {Scope as BabelScope} from '@babel/traverse';
 
-import {CompilerError, ErrorSeverity} from '../CompilerError';
+import {CompilerError, ErrorCategory, ErrorSeverity} from '../CompilerError';
 import {
   EnvironmentConfig,
   GeneratedSource,
@@ -38,10 +38,11 @@ export function validateRestrictedImports(
     ImportDeclaration(importDeclPath) {
       if (restrictedImports.has(importDeclPath.node.source.value)) {
         error.push({
+          category: ErrorCategory.Todo,
+          severity: ErrorSeverity.Todo,
           reason: 'Bailing out due to blocklisted import',
           description: `Import from module ${importDeclPath.node.source.value}`,
           loc: importDeclPath.node.loc ?? null,
-          severity: ErrorSeverity.Todo,
         });
       }
     },
@@ -205,10 +206,11 @@ export class ProgramContext {
     }
     const error = new CompilerError();
     error.push({
+      category: ErrorCategory.Todo,
+      severity: ErrorSeverity.Todo,
       reason: 'Encountered conflicting global in generated program',
       description: `Conflict from local binding ${name}`,
       loc: scope.getBinding(name)?.path.node.loc ?? null,
-      severity: ErrorSeverity.Todo,
       suggestions: null,
     });
     return Err(error);

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

@@ -11,7 +11,7 @@ import {
   CompilerDiagnostic,
   CompilerError,
   CompilerErrorDetail,
-  PlainCompilerErrorDetailOptions,
+  CompilerErrorDetailOptions,
 } from '../CompilerError';
 import {
   EnvironmentConfig,
@@ -107,8 +107,6 @@ export type PluginOptions = {
    * passes.
    *
    * Defaults to false
-   *
-   * TODO: rename this to lintOnly or something similar
    */
   noEmit: boolean;
 
@@ -236,10 +234,7 @@ export type CompileErrorEvent = {
 export type CompileDiagnosticEvent = {
   kind: 'CompileDiagnostic';
   fnLoc: t.SourceLocation | null;
-  detail: Omit<
-    Omit<PlainCompilerErrorDetailOptions, 'severity'>,
-    'suggestions'
-  >;
+  detail: Omit<Omit<CompilerErrorDetailOptions, 'severity'>, 'suggestions'>;
 };
 export type CompileSuccessEvent = {
   kind: 'CompileSuccess';

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

@@ -33,9 +33,7 @@ import {findContextIdentifiers} from '../HIR/FindContextIdentifiers';
 import {
   analyseFunctions,
   dropManualMemoization,
-  inferMutableRanges,
   inferReactivePlaces,
-  inferReferenceEffects,
   inlineImmediatelyInvokedFunctionExpressions,
   inferEffectDependencies,
 } from '../Inference';
@@ -173,7 +171,7 @@ function runWithEnvironment(
     !env.config.disableMemoizationForDebugging &&
     !env.config.enableChangeDetectionForDebugging
   ) {
-    env.logOrThrowErrors(dropManualMemoization(hir));
+    dropManualMemoization(hir).unwrap();
     log({kind: 'hir', name: 'DropManualMemoization', value: hir});
   }
 
@@ -206,10 +204,10 @@ function runWithEnvironment(
 
   if (env.isInferredMemoEnabled) {
     if (env.config.validateHooksUsage) {
-      env.logOrThrowErrors(validateHooksUsage(hir));
+      validateHooksUsage(hir).unwrap();
     }
-    if (env.config.validateNoCapitalizedCalls != null) {
-      env.logOrThrowErrors(validateNoCapitalizedCalls(hir));
+    if (env.config.validateNoCapitalizedCalls) {
+      validateNoCapitalizedCalls(hir).unwrap();
     }
   }
 
@@ -228,23 +226,12 @@ function runWithEnvironment(
   analyseFunctions(hir);
   log({kind: 'hir', name: 'AnalyseFunctions', value: hir});
 
-  if (!env.config.enableNewMutationAliasingModel) {
-    const fnEffectResult = inferReferenceEffects(hir);
-
-    if (env.isInferredMemoEnabled) {
-      env.logOrThrowErrors(fnEffectResult);
+  const mutabilityAliasingErrors = inferMutationAliasingEffects(hir);
+  log({kind: 'hir', name: 'InferMutationAliasingEffects', value: hir});
+  if (env.isInferredMemoEnabled) {
+    if (mutabilityAliasingErrors.isErr()) {
+      throw mutabilityAliasingErrors.unwrapErr();
     }
-    log({kind: 'hir', name: 'InferReferenceEffects', value: hir});
-  } else {
-    const mutabilityAliasingErrors = inferMutationAliasingEffects(hir);
-    log({kind: 'hir', name: 'InferMutationAliasingEffects', value: hir});
-    if (env.isInferredMemoEnabled) {
-      env.logOrThrowErrors(mutabilityAliasingErrors);
-    }
-  }
-
-  if (!env.config.enableNewMutationAliasingModel) {
-    validateLocalsNotReassignedAfterRender(hir);
   }
 
   // Note: Has to come after infer reference effects because "dead" code may still affect inference
@@ -259,18 +246,15 @@ function runWithEnvironment(
   pruneMaybeThrows(hir);
   log({kind: 'hir', name: 'PruneMaybeThrows', value: hir});
 
-  if (!env.config.enableNewMutationAliasingModel) {
-    inferMutableRanges(hir);
-    log({kind: 'hir', name: 'InferMutableRanges', value: hir});
-  } else {
-    const mutabilityAliasingErrors = inferMutationAliasingRanges(hir, {
-      isFunctionExpression: false,
-    });
-    log({kind: 'hir', name: 'InferMutationAliasingRanges', value: hir});
-    if (env.isInferredMemoEnabled) {
-      env.logOrThrowErrors(mutabilityAliasingErrors.map(() => undefined));
-      env.logOrThrowErrors(validateLocalsNotReassignedAfterRender(hir));
+  const mutabilityAliasingRangeErrors = inferMutationAliasingRanges(hir, {
+    isFunctionExpression: false,
+  });
+  log({kind: 'hir', name: 'InferMutationAliasingRanges', value: hir});
+  if (env.isInferredMemoEnabled) {
+    if (mutabilityAliasingRangeErrors.isErr()) {
+      throw mutabilityAliasingRangeErrors.unwrapErr();
     }
+    validateLocalsNotReassignedAfterRender(hir);
   }
 
   if (env.isInferredMemoEnabled) {
@@ -279,15 +263,15 @@ function runWithEnvironment(
     }
 
     if (env.config.validateRefAccessDuringRender) {
-      env.logOrThrowErrors(validateNoRefAccessInRender(hir));
+      validateNoRefAccessInRender(hir).unwrap();
     }
 
     if (env.config.validateNoSetStateInRender) {
-      env.logOrThrowErrors(validateNoSetStateInRender(hir));
+      validateNoSetStateInRender(hir).unwrap();
     }
 
     if (env.config.validateNoDerivedComputationsInEffects) {
-      env.logOrThrowErrors(validateNoDerivedComputationsInEffects(hir));
+      validateNoDerivedComputationsInEffects(hir);
     }
 
     if (env.config.validateNoSetStateInEffects) {
@@ -297,19 +281,12 @@ function runWithEnvironment(
     if (env.config.validateNoJSXInTryStatements) {
       env.logErrors(validateNoJSXInTryStatement(hir));
     }
-    if (
-      env.config.validateNoImpureFunctionsInRender &&
-      !env.config.enableNewMutationAliasingModel
-    ) {
-      env.logOrThrowErrors(validateNoImpureFunctionsInRender(hir));
+
+    if (env.config.validateNoImpureFunctionsInRender) {
+      validateNoImpureFunctionsInRender(hir).unwrap();
     }
 
-    if (
-      env.config.validateNoFreezingKnownMutableFunctions ||
-      env.config.enableNewMutationAliasingModel
-    ) {
-      env.logOrThrowErrors(validateNoFreezingKnownMutableFunctions(hir));
-    }
+    validateNoFreezingKnownMutableFunctions(hir).unwrap();
   }
 
   inferReactivePlaces(hir);

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

@@ -7,7 +7,12 @@
 
 import {NodePath} from '@babel/core';
 import * as t from '@babel/types';
-import {CompilerError, ErrorSeverity} from '../CompilerError';
+import {
+  CompilerError,
+  CompilerErrorDetail,
+  ErrorCategory,
+  ErrorSeverity,
+} from '../CompilerError';
 import {ExternalFunction, ReactFunctionType} from '../HIR/Environment';
 import {CodegenFunction} from '../ReactiveScopes';
 import {isComponentDeclaration} from '../Utils/ComponentDeclaration';
@@ -28,7 +33,6 @@ import {
 } from './Suppression';
 import {GeneratedSource} from '../HIR';
 import {Err, Ok, Result} from '../Utils/Result';
-import {ErrorCode} from '../Utils/CompilerErrorCodes';
 
 export type CompilerPass = {
   opts: PluginOptions;
@@ -98,9 +102,13 @@ function findDirectivesDynamicGating(
       if (t.isValidIdentifier(maybeMatch[1])) {
         result.push({directive, match: maybeMatch[1]});
       } else {
-        errors.pushErrorCode(ErrorCode.DYNAMIC_GATING_IS_NOT_IDENTIFIER, {
+        errors.push({
+          reason: `Dynamic gating directive is not a valid JavaScript identifier`,
           description: `Found '${directive.value.value}'`,
+          severity: ErrorSeverity.InvalidReact,
+          category: ErrorCategory.Gating,
           loc: directive.loc ?? null,
+          suggestions: null,
         });
       }
     }
@@ -109,11 +117,15 @@ function findDirectivesDynamicGating(
     return Err(errors);
   } else if (result.length > 1) {
     const error = new CompilerError();
-    error.pushErrorCode(ErrorCode.DYNAMIC_GATING_MULTIPLE_DIRECTIVES, {
+    error.push({
+      reason: `Multiple dynamic gating directives found`,
       description: `Expected a single directive but found [${result
         .map(r => r.directive.value.value)
         .join(', ')}]`,
+      severity: ErrorSeverity.InvalidReact,
+      category: ErrorCategory.Gating,
       loc: result[0].directive.loc ?? null,
+      suggestions: null,
     });
     return Err(error);
   } else if (result.length === 1) {
@@ -442,12 +454,15 @@ export function compileProgram(
   if (programContext.hasModuleScopeOptOut) {
     if (compiledFns.length > 0) {
       const error = new CompilerError();
-      error.push({
-        reason:
-          'Unexpected compiled functions when module scope opt-out is present',
-        severity: ErrorSeverity.Invariant,
-        loc: null,
-      });
+      error.pushErrorDetail(
+        new CompilerErrorDetail({
+          reason:
+            'Unexpected compiled functions when module scope opt-out is present',
+          severity: ErrorSeverity.Invariant,
+          category: ErrorCategory.Invariant,
+          loc: null,
+        }),
+      );
       handleError(error, programContext, null);
     }
     return null;
@@ -580,7 +595,9 @@ function processFn(
   let compiledFn: CodegenFunction;
   const compileResult = tryCompileFunction(fn, fnType, programContext);
   if (compileResult.kind === 'error') {
-    if (directives.optOut == null) {
+    if (directives.optOut != null) {
+      logError(compileResult.error, programContext, fn.node.loc ?? null);
+    } else {
       handleError(compileResult.error, programContext, fn.node.loc ?? null);
     }
     const retryResult = retryCompileFunction(fn, fnType, programContext);
@@ -679,7 +696,7 @@ function tryCompileFunction(
         fn,
         programContext.opts.environment,
         fnType,
-        programContext.opts.noEmit ? 'lint_only' : 'all_features',
+        'all_features',
         programContext,
         programContext.opts.logger,
         programContext.filename,
@@ -792,7 +809,16 @@ function shouldSkipCompilation(
   if (pass.opts.sources) {
     if (pass.filename === null) {
       const error = new CompilerError();
-      error.pushErrorCode(ErrorCode.FILENAME_NOT_SET);
+      error.pushErrorDetail(
+        new CompilerErrorDetail({
+          reason: `Expected a filename but found none.`,
+          description:
+            "When the 'sources' config options is specified, the React compiler will only compile files with a name",
+          severity: ErrorSeverity.InvalidConfig,
+          category: ErrorCategory.Config,
+          loc: null,
+        }),
+      );
       handleError(error, pass, null);
       return true;
     }

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

@@ -11,7 +11,8 @@ import {
   CompilerDiagnostic,
   CompilerError,
   CompilerSuggestionOperation,
-  ErrorCode,
+  ErrorCategory,
+  ErrorSeverity,
 } from '../CompilerError';
 import {assertExhaustive} from '../Utils/utils';
 import {GeneratedSource} from '../HIR';
@@ -165,12 +166,14 @@ export function suppressionsToCompilerError(
     let reason, suggestion;
     switch (suppressionRange.source) {
       case 'Eslint':
-        reason = ErrorCode.BAILOUT_ESLINT_SUPPRESSION;
+        reason =
+          'React Compiler has skipped optimizing this component because one or more React ESLint rules were disabled';
         suggestion =
           'Remove the ESLint suppression and address the React error';
         break;
       case 'Flow':
-        reason = ErrorCode.BAILOUT_FLOW_SUPPRESSION;
+        reason =
+          'React Compiler has skipped optimizing this component because one or more React rule violations were reported by Flow';
         suggestion = 'Remove the Flow suppression and address the React error';
         break;
       default:
@@ -180,8 +183,11 @@ export function suppressionsToCompilerError(
         );
     }
     error.pushDiagnostic(
-      CompilerDiagnostic.fromCode(reason, {
-        description: `Found suppression \`${suppressionRange.disableComment.value.trim()}\``,
+      CompilerDiagnostic.create({
+        reason: 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()}\``,
+        severity: ErrorSeverity.InvalidReact,
+        category: ErrorCategory.Suppression,
         suggestions: [
           {
             description: suggestion,

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

@@ -8,24 +8,31 @@
 import {NodePath} from '@babel/core';
 import * as t from '@babel/types';
 
-import {CompilerError, EnvironmentConfig, Logger} from '..';
+import {CompilerError, EnvironmentConfig, ErrorSeverity, Logger} from '..';
 import {getOrInsertWith} from '../Utils/utils';
 import {Environment, GeneratedSource} from '../HIR';
 import {DEFAULT_EXPORT} from '../HIR/Environment';
 import {CompileProgramMetadata} from './Program';
-import {CompilerDiagnostic} from '../CompilerError';
-import {ErrorCode} from '../Utils/CompilerErrorCodes';
+import {
+  CompilerDiagnostic,
+  CompilerDiagnosticOptions,
+  ErrorCategory,
+} from '../CompilerError';
 
-function logAndThrowDiagnostic(
-  diagnostic: CompilerDiagnostic,
+function throwInvalidReact(
+  options: Omit<CompilerDiagnosticOptions, 'severity'>,
   {logger, filename}: TraversalState,
 ): never {
+  const detail: CompilerDiagnosticOptions = {
+    severity: ErrorSeverity.InvalidReact,
+    ...options,
+  };
   logger?.logEvent(filename, {
     kind: 'CompileError',
     fnLoc: null,
-    detail: diagnostic,
+    detail: new CompilerDiagnostic(detail),
   });
-  CompilerError.throwDiagnostic(diagnostic);
+  CompilerError.throwDiagnostic(detail);
 }
 
 function isAutodepsSigil(
@@ -87,9 +94,14 @@ function assertValidEffectImportReference(
          * as it may have already been transformed by the compiler (and not
          * memoized).
          */
-        logAndThrowDiagnostic(
-          CompilerDiagnostic.fromCode(ErrorCode.DID_NOT_INFER_DEPS, {
-            description: maybeErrorDiagnostic ? `${maybeErrorDiagnostic}` : '',
+        throwInvalidReact(
+          {
+            category: ErrorCategory.AutomaticEffectDependencies,
+            reason:
+              'Cannot infer dependencies of this effect. This will break your build!',
+            description:
+              'To resolve, either pass a dependency array or fix reported compiler bailout diagnostics.' +
+              (maybeErrorDiagnostic ? ` ${maybeErrorDiagnostic}` : ''),
             details: [
               {
                 kind: 'error',
@@ -97,7 +109,7 @@ function assertValidEffectImportReference(
                 loc: parent.node.loc ?? GeneratedSource,
               },
             ],
-          }),
+          },
           context,
         );
       }
@@ -114,8 +126,10 @@ function assertValidFireImportReference(
       paths[0],
       context.transformErrors,
     );
-    logAndThrowDiagnostic(
-      CompilerDiagnostic.fromCode(ErrorCode.CANNOT_COMPILE_FIRE, {
+    throwInvalidReact(
+      {
+        category: ErrorCategory.Fire,
+        reason: '[Fire] Untransformed reference to compiler-required feature.',
         description:
           'Either remove this `fire` call or ensure it is successfully transformed by the compiler' +
           maybeErrorDiagnostic
@@ -128,7 +142,7 @@ function assertValidFireImportReference(
             loc: paths[0].node.loc ?? GeneratedSource,
           },
         ],
-      }),
+      },
       context,
     );
   }

compiler/packages/babel-plugin-react-compiler/src/Flood/TypeErrors.ts

@@ -1,5 +1,4 @@
 import {CompilerError, SourceLocation} from '..';
-import {ErrorCode} from '../CompilerError';
 import {
   ConcreteType,
   printConcrete,
@@ -13,8 +12,8 @@ export function unsupportedLanguageFeature(
   desc: string,
   loc: SourceLocation,
 ): never {
-  CompilerError.throwFromCode(ErrorCode.INVALID_JAVASCRIPT_AST, {
-    description: `Typedchecker does not currently support language feature: ${desc}`,
+  CompilerError.throwInvalidJS({
+    reason: `Typedchecker does not currently support language feature: ${desc}`,
     loc,
   });
 }
@@ -50,16 +49,16 @@ export function raiseUnificationErrors(
         loc,
       });
     } else if (errs.length === 1) {
-      CompilerError.throwFromCode(ErrorCode.INVALID_JAVASCRIPT_AST, {
-        description: `Unable to unify types because ${printUnificationError(errs[0])}`,
+      CompilerError.throwInvalidJS({
+        reason: `Unable to unify types because ${printUnificationError(errs[0])}`,
         loc,
       });
     } else {
       const messages = errs
         .map(err => `\t* ${printUnificationError(err)}`)
         .join('\n');
-      CompilerError.throwFromCode(ErrorCode.INVALID_JAVASCRIPT_AST, {
-        description: `Unable to unify types because:\n${messages}`,
+      CompilerError.throwInvalidJS({
+        reason: `Unable to unify types because:\n${messages}`,
         loc,
       });
     }
@@ -70,21 +69,21 @@ export function unresolvableTypeVariable(
   id: VariableId,
   loc: SourceLocation,
 ): never {
-  CompilerError.throwFromCode(ErrorCode.INVALID_JAVASCRIPT_AST, {
-    description: `Unable to resolve free variable ${id} to a concrete type`,
+  CompilerError.throwInvalidJS({
+    reason: `Unable to resolve free variable ${id} to a concrete type`,
     loc,
   });
 }
 
 export function cannotAddVoid(explicit: boolean, loc: SourceLocation): never {
   if (explicit) {
-    CompilerError.throwFromCode(ErrorCode.INVALID_JAVASCRIPT_AST, {
-      description: `Undefined is not a valid operand of \`+\``,
+    CompilerError.throwInvalidJS({
+      reason: `Undefined is not a valid operand of \`+\``,
       loc,
     });
   } else {
-    CompilerError.throwFromCode(ErrorCode.INVALID_JAVASCRIPT_AST, {
-      description: `Value may be undefined, which is not a valid operand of \`+\``,
+    CompilerError.throwInvalidJS({
+      reason: `Value may be undefined, which is not a valid operand of \`+\``,
       loc,
     });
   }
@@ -94,8 +93,8 @@ export function unsupportedTypeAnnotation(
   desc: string,
   loc: SourceLocation,
 ): never {
-  CompilerError.throwFromCode(ErrorCode.INVALID_JAVASCRIPT_AST, {
-    description: `Typedchecker does not currently support type annotation: ${desc}`,
+  CompilerError.throwInvalidJS({
+    reason: `Typedchecker does not currently support type annotation: ${desc}`,
     loc,
   });
 }
@@ -107,16 +106,16 @@ export function checkTypeArgumentArity(
   loc: SourceLocation,
 ): void {
   if (expected !== actual) {
-    CompilerError.throwFromCode(ErrorCode.INVALID_JAVASCRIPT_AST, {
-      description: `Expected ${desc} to have ${expected} type parameters, got ${actual}`,
+    CompilerError.throwInvalidJS({
+      reason: `Expected ${desc} to have ${expected} type parameters, got ${actual}`,
       loc,
     });
   }
 }
 
 export function notAFunction(desc: string, loc: SourceLocation): void {
-  CompilerError.throwFromCode(ErrorCode.INVALID_JAVASCRIPT_AST, {
-    description: `Cannot call ${desc} because it is not a function`,
+  CompilerError.throwInvalidJS({
+    reason: `Cannot call ${desc} because it is not a function`,
     loc,
   });
 }
@@ -125,8 +124,8 @@ export function notAPolymorphicFunction(
   desc: string,
   loc: SourceLocation,
 ): void {
-  CompilerError.throwFromCode(ErrorCode.INVALID_JAVASCRIPT_AST, {
-    description: `Cannot call ${desc} with type arguments because it is not a polymorphic function`,
+  CompilerError.throwInvalidJS({
+    reason: `Cannot call ${desc} with type arguments because it is not a polymorphic function`,
     loc,
   });
 }

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

@@ -12,7 +12,7 @@ import {
   CompilerDiagnostic,
   CompilerError,
   CompilerSuggestionOperation,
-  ErrorCode,
+  ErrorCategory,
   ErrorSeverity,
 } from '../CompilerError';
 import {Err, Ok, Result} from '../Utils/Result';
@@ -109,7 +109,8 @@ export function lower(
         builder.errors.pushDiagnostic(
           CompilerDiagnostic.create({
             severity: ErrorSeverity.Invariant,
-            category: 'Could not find binding',
+            category: ErrorCategory.Invariant,
+            reason: 'Could not find binding',
             description: `[BuildHIR] Could not find binding for param \`${param.node.name}\`.`,
           }).withDetail({
             kind: 'error',
@@ -171,12 +172,15 @@ export function lower(
       );
     } else {
       builder.errors.pushDiagnostic(
-        CompilerDiagnostic.fromCode(ErrorCode.UNKNOWN_FUNCTION_PARAMETERS, {
+        CompilerDiagnostic.create({
+          severity: ErrorSeverity.Todo,
+          category: ErrorCategory.Todo,
+          reason: `Handle ${param.node.type} parameters`,
           description: `[BuildHIR] Add support for ${param.node.type} parameters.`,
         }).withDetail({
           kind: 'error',
           loc: param.node.loc ?? null,
-          message: `Unsupported parameter type: ${param.node.type}`,
+          message: 'Unsupported parameter type',
         }),
       );
     }
@@ -200,12 +204,15 @@ export function lower(
     directives = body.get('directives').map(d => d.node.value.value);
   } else {
     builder.errors.pushDiagnostic(
-      CompilerDiagnostic.fromCode(ErrorCode.INVALID_JAVASCRIPT_AST, {
+      CompilerDiagnostic.create({
+        severity: ErrorSeverity.InvalidJS,
+        category: ErrorCategory.Syntax,
+        reason: `Unexpected function body kind`,
         description: `Expected function body to be an expression or a block statement, got \`${body.type}\`.`,
       }).withDetail({
         kind: 'error',
         loc: body.node.loc ?? null,
-        message: 'Change this to a block statement or expression',
+        message: 'Expected a block statement or expression',
       }),
     );
   }
@@ -270,6 +277,7 @@ function lowerStatement(
           reason:
             '(BuildHIR::lowerStatement) Support ThrowStatement inside of try/catch',
           severity: ErrorSeverity.Todo,
+          category: ErrorCategory.Todo,
           loc: stmt.node.loc ?? null,
           suggestions: null,
         });
@@ -457,6 +465,7 @@ function lowerStatement(
           } else if (!binding.path.isVariableDeclarator()) {
             builder.errors.push({
               severity: ErrorSeverity.Todo,
+              category: ErrorCategory.Todo,
               reason: 'Unsupported declaration type for hoisting',
               description: `variable "${binding.identifier.name}" declared with ${binding.path.type}`,
               suggestions: null,
@@ -466,6 +475,7 @@ function lowerStatement(
           } else {
             builder.errors.push({
               severity: ErrorSeverity.Todo,
+              category: ErrorCategory.Todo,
               reason: 'Handle non-const declarations for hoisting',
               description: `variable "${binding.identifier.name}" declared with ${binding.kind}`,
               suggestions: null,
@@ -546,6 +556,7 @@ function lowerStatement(
             reason:
               '(BuildHIR::lowerStatement) Handle non-variable initialization in ForStatement',
             severity: ErrorSeverity.Todo,
+            category: ErrorCategory.Todo,
             loc: stmt.node.loc ?? null,
             suggestions: null,
           });
@@ -618,6 +629,7 @@ function lowerStatement(
         builder.errors.push({
           reason: `(BuildHIR::lowerStatement) Handle empty test in ForStatement`,
           severity: ErrorSeverity.Todo,
+          category: ErrorCategory.Todo,
           loc: stmt.node.loc ?? null,
           suggestions: null,
         });
@@ -766,12 +778,13 @@ function lowerStatement(
         const testExpr = case_.get('test');
         if (testExpr.node == null) {
           if (hasDefault) {
-            builder.errors.pushErrorCode(
-              ErrorCode.INVALID_SYNTAX_MULTIPLE_DEFAULTS,
-              {
-                loc: case_.node.loc ?? null,
-              },
-            );
+            builder.errors.push({
+              reason: `Expected at most one \`default\` branch in a switch statement, this code should have failed to parse`,
+              severity: ErrorSeverity.InvalidJS,
+              category: ErrorCategory.Syntax,
+              loc: case_.node.loc ?? null,
+              suggestions: null,
+            });
             break;
           }
           hasDefault = true;
@@ -841,6 +854,7 @@ function lowerStatement(
         builder.errors.push({
           reason: `(BuildHIR::lowerStatement) Handle ${nodeKind} kinds in VariableDeclaration`,
           severity: ErrorSeverity.Todo,
+          category: ErrorCategory.Todo,
           loc: stmt.node.loc ?? null,
           suggestions: null,
         });
@@ -869,6 +883,7 @@ function lowerStatement(
             builder.errors.push({
               reason: `(BuildHIR::lowerAssignment) Could not find binding for declaration.`,
               severity: ErrorSeverity.Invariant,
+              category: ErrorCategory.Invariant,
               loc: id.node.loc ?? null,
               suggestions: null,
             });
@@ -883,20 +898,20 @@ function lowerStatement(
             if (builder.isContextIdentifier(id)) {
               if (kind === InstructionKind.Const) {
                 const declRangeStart = declaration.parentPath.node.start!;
-                builder.errors.pushErrorCode(
-                  ErrorCode.INVALID_SYNTAX_REASSIGNED_CONST,
-                  {
-                    loc: id.node.loc ?? null,
-                    suggestions: [
-                      {
-                        description: 'Change to a `let` declaration',
-                        op: CompilerSuggestionOperation.Replace,
-                        range: [declRangeStart, declRangeStart + 5], // "const".length
-                        text: 'let',
-                      },
-                    ],
-                  },
-                );
+                builder.errors.push({
+                  reason: `Expect \`const\` declaration not to be reassigned`,
+                  severity: ErrorSeverity.InvalidJS,
+                  category: ErrorCategory.Syntax,
+                  loc: id.node.loc ?? null,
+                  suggestions: [
+                    {
+                      description: 'Change to a `let` declaration',
+                      op: CompilerSuggestionOperation.Replace,
+                      range: [declRangeStart, declRangeStart + 5], // "const".length
+                      text: 'let',
+                    },
+                  ],
+                });
               }
               lowerValueToTemporary(builder, {
                 kind: 'DeclareContext',
@@ -930,13 +945,14 @@ function lowerStatement(
             }
           }
         } else {
-          builder.errors.pushErrorCode(
-            ErrorCode.INVALID_SYNTAX_BAD_VARIABLE_DECL,
-            {
-              description: `Got a \`${id.type}\``,
-              loc: stmt.node.loc ?? null,
-            },
-          );
+          builder.errors.push({
+            reason: `Expected variable declaration to be an identifier if no initializer was provided`,
+            description: `Got a \`${id.type}\``,
+            severity: ErrorSeverity.InvalidJS,
+            category: ErrorCategory.Syntax,
+            loc: stmt.node.loc ?? null,
+            suggestions: null,
+          });
         }
       }
       return;
@@ -1042,6 +1058,7 @@ function lowerStatement(
         builder.errors.push({
           reason: `(BuildHIR::lowerStatement) Handle for-await loops`,
           severity: ErrorSeverity.Todo,
+          category: ErrorCategory.Todo,
           loc: stmt.node.loc ?? null,
           suggestions: null,
         });
@@ -1274,6 +1291,7 @@ function lowerStatement(
         builder.errors.push({
           reason: `(BuildHIR::lowerStatement) Handle TryStatement without a catch clause`,
           severity: ErrorSeverity.Todo,
+          category: ErrorCategory.Todo,
           loc: stmt.node.loc ?? null,
           suggestions: null,
         });
@@ -1283,6 +1301,7 @@ function lowerStatement(
         builder.errors.push({
           reason: `(BuildHIR::lowerStatement) Handle TryStatement with a finalizer ('finally') clause`,
           severity: ErrorSeverity.Todo,
+          category: ErrorCategory.Todo,
           loc: stmt.node.loc ?? null,
           suggestions: null,
         });
@@ -1372,8 +1391,13 @@ function lowerStatement(
       return;
     }
     case 'WithStatement': {
-      builder.errors.pushErrorCode(ErrorCode.UNSUPPORTED_WITH, {
+      builder.errors.push({
+        reason: `JavaScript 'with' syntax is not supported`,
+        description: `'with' syntax is considered deprecated and removed from JavaScript standards, consider alternatives`,
+        severity: ErrorSeverity.UnsupportedJS,
+        category: ErrorCategory.UnsupportedSyntax,
         loc: stmtPath.node.loc ?? null,
+        suggestions: null,
       });
       lowerValueToTemporary(builder, {
         kind: 'UnsupportedNode',
@@ -1388,8 +1412,13 @@ function lowerStatement(
        * and complex enough to support that we don't anticipate supporting anytime soon. Developers
        * are encouraged to lift classes out of component/hook declarations.
        */
-      builder.errors.pushErrorCode(ErrorCode.UNSUPPORTED_INNER_CLASS, {
+      builder.errors.push({
+        reason: 'Inline `class` declarations are not supported',
+        description: `Move class declarations outside of components/hooks`,
+        severity: ErrorSeverity.UnsupportedJS,
+        category: ErrorCategory.UnsupportedSyntax,
         loc: stmtPath.node.loc ?? null,
+        suggestions: null,
       });
       lowerValueToTemporary(builder, {
         kind: 'UnsupportedNode',
@@ -1413,8 +1442,13 @@ function lowerStatement(
     case 'ImportDeclaration':
     case 'TSExportAssignment':
     case 'TSImportEqualsDeclaration': {
-      builder.errors.pushErrorCode(ErrorCode.INVALID_IMPORT_EXPORT, {
+      builder.errors.push({
+        reason:
+          'JavaScript `import` and `export` statements may only appear at the top level of a module',
+        severity: ErrorSeverity.InvalidJS,
+        category: ErrorCategory.Syntax,
         loc: stmtPath.node.loc ?? null,
+        suggestions: null,
       });
       lowerValueToTemporary(builder, {
         kind: 'UnsupportedNode',
@@ -1424,8 +1458,13 @@ function lowerStatement(
       return;
     }
     case 'TSNamespaceExportDeclaration': {
-      builder.errors.pushErrorCode(ErrorCode.INVALID_TS_NAMESPACE, {
+      builder.errors.push({
+        reason:
+          'TypeScript `namespace` statements may only appear at the top level of a module',
+        severity: ErrorSeverity.InvalidJS,
+        category: ErrorCategory.Syntax,
         loc: stmtPath.node.loc ?? null,
+        suggestions: null,
       });
       lowerValueToTemporary(builder, {
         kind: 'UnsupportedNode',
@@ -1502,6 +1541,7 @@ function lowerObjectPropertyKey(
       builder.errors.push({
         reason: `(BuildHIR::lowerExpression) Expected Identifier, got ${key.type} key in ObjectExpression`,
         severity: ErrorSeverity.Todo,
+        category: ErrorCategory.Todo,
         loc: key.node.loc ?? null,
         suggestions: null,
       });
@@ -1527,6 +1567,7 @@ function lowerObjectPropertyKey(
   builder.errors.push({
     reason: `(BuildHIR::lowerExpression) Expected Identifier, got ${key.type} key in ObjectExpression`,
     severity: ErrorSeverity.Todo,
+    category: ErrorCategory.Todo,
     loc: key.node.loc ?? null,
     suggestions: null,
   });
@@ -1584,6 +1625,7 @@ function lowerExpression(
             builder.errors.push({
               reason: `(BuildHIR::lowerExpression) Handle ${valuePath.type} values in ObjectExpression`,
               severity: ErrorSeverity.Todo,
+              category: ErrorCategory.Todo,
               loc: valuePath.node.loc ?? null,
               suggestions: null,
             });
@@ -1610,6 +1652,7 @@ function lowerExpression(
             builder.errors.push({
               reason: `(BuildHIR::lowerExpression) Handle ${propertyPath.node.kind} functions in ObjectExpression`,
               severity: ErrorSeverity.Todo,
+              category: ErrorCategory.Todo,
               loc: propertyPath.node.loc ?? null,
               suggestions: null,
             });
@@ -1631,6 +1674,7 @@ function lowerExpression(
           builder.errors.push({
             reason: `(BuildHIR::lowerExpression) Handle ${propertyPath.type} properties in ObjectExpression`,
             severity: ErrorSeverity.Todo,
+            category: ErrorCategory.Todo,
             loc: propertyPath.node.loc ?? null,
             suggestions: null,
           });
@@ -1664,6 +1708,7 @@ function lowerExpression(
           builder.errors.push({
             reason: `(BuildHIR::lowerExpression) Handle ${element.type} elements in ArrayExpression`,
             severity: ErrorSeverity.Todo,
+            category: ErrorCategory.Todo,
             loc: element.node.loc ?? null,
             suggestions: null,
           });
@@ -1680,8 +1725,13 @@ function lowerExpression(
       const expr = exprPath as NodePath<t.NewExpression>;
       const calleePath = expr.get('callee');
       if (!calleePath.isExpression()) {
-        builder.errors.pushErrorCode(ErrorCode.UNSUPPORTED_NEW_EXPRESSION, {
+        builder.errors.push({
+          reason: `Expected an expression as the \`new\` expression receiver (v8 intrinsics are not supported)`,
+          description: `Got a \`${calleePath.node.type}\``,
+          severity: ErrorSeverity.InvalidJS,
+          category: ErrorCategory.Syntax,
           loc: calleePath.node.loc ?? null,
+          suggestions: null,
         });
         return {kind: 'UnsupportedNode', node: exprNode, loc: exprLoc};
       }
@@ -1706,6 +1756,7 @@ function lowerExpression(
         builder.errors.push({
           reason: `Expected Expression, got ${calleePath.type} in CallExpression (v8 intrinsics not supported). This error is likely caused by a bug in React Compiler. Please file an issue`,
           severity: ErrorSeverity.Todo,
+          category: ErrorCategory.Todo,
           loc: calleePath.node.loc ?? null,
           suggestions: null,
         });
@@ -1740,6 +1791,7 @@ function lowerExpression(
         builder.errors.push({
           reason: `(BuildHIR::lowerExpression) Expected Expression, got ${leftPath.type} lval in BinaryExpression`,
           severity: ErrorSeverity.Todo,
+          category: ErrorCategory.Todo,
           loc: leftPath.node.loc ?? null,
           suggestions: null,
         });
@@ -1752,6 +1804,7 @@ function lowerExpression(
         builder.errors.push({
           reason: `(BuildHIR::lowerExpression) Pipe operator not supported`,
           severity: ErrorSeverity.Todo,
+          category: ErrorCategory.Todo,
           loc: leftPath.node.loc ?? null,
           suggestions: null,
         });
@@ -1778,12 +1831,13 @@ function lowerExpression(
           last = lowerExpressionToTemporary(builder, item);
         }
         if (last === null) {
-          builder.errors.pushErrorCode(
-            ErrorCode.UNSUPPORTED_EMPTY_SEQUENCE_EXPRESSION,
-            {
-              loc: expr.node.loc ?? null,
-            },
-          );
+          builder.errors.push({
+            reason: `Expected sequence expression to have at least one expression`,
+            severity: ErrorSeverity.InvalidJS,
+            category: ErrorCategory.Syntax,
+            loc: expr.node.loc ?? null,
+            suggestions: null,
+          });
         } else {
           lowerValueToTemporary(builder, {
             kind: 'StoreLocal',
@@ -1993,6 +2047,7 @@ function lowerExpression(
             reason: `(BuildHIR::lowerExpression) Unsupported syntax on the left side of an AssignmentExpression`,
             description: `Expected an LVal, got: ${left.type}`,
             severity: ErrorSeverity.Todo,
+            category: ErrorCategory.Todo,
             loc: left.node.loc ?? null,
             suggestions: null,
           });
@@ -2021,6 +2076,7 @@ function lowerExpression(
         builder.errors.push({
           reason: `(BuildHIR::lowerExpression) Handle ${operator} operators in AssignmentExpression`,
           severity: ErrorSeverity.Todo,
+          category: ErrorCategory.Todo,
           loc: expr.node.loc ?? null,
           suggestions: null,
         });
@@ -2120,6 +2176,7 @@ function lowerExpression(
           builder.errors.push({
             reason: `(BuildHIR::lowerExpression) Expected Identifier or MemberExpression, got ${expr.type} lval in AssignmentExpression`,
             severity: ErrorSeverity.Todo,
+            category: ErrorCategory.Todo,
             loc: expr.node.loc ?? null,
             suggestions: null,
           });
@@ -2159,6 +2216,7 @@ function lowerExpression(
           builder.errors.push({
             reason: `(BuildHIR::lowerExpression) Handle ${attribute.type} attributes in JSXElement`,
             severity: ErrorSeverity.Todo,
+            category: ErrorCategory.Todo,
             loc: attribute.node.loc ?? null,
             suggestions: null,
           });
@@ -2172,6 +2230,7 @@ function lowerExpression(
             builder.errors.push({
               reason: `(BuildHIR::lowerExpression) Unexpected colon in attribute name \`${propName}\``,
               severity: ErrorSeverity.Todo,
+              category: ErrorCategory.Todo,
               loc: namePath.node.loc ?? null,
               suggestions: null,
             });
@@ -2202,6 +2261,7 @@ function lowerExpression(
             builder.errors.push({
               reason: `(BuildHIR::lowerExpression) Handle ${valueExpr.type} attribute values in JSXElement`,
               severity: ErrorSeverity.Todo,
+              category: ErrorCategory.Todo,
               loc: valueExpr.node?.loc ?? null,
               suggestions: null,
             });
@@ -2212,6 +2272,7 @@ function lowerExpression(
             builder.errors.push({
               reason: `(BuildHIR::lowerExpression) Handle ${expression.type} expressions in JSXExpressionContainer within JSXElement`,
               severity: ErrorSeverity.Todo,
+              category: ErrorCategory.Todo,
               loc: valueExpr.node.loc ?? null,
               suggestions: null,
             });
@@ -2267,18 +2328,19 @@ function lowerExpression(
         });
         for (const [name, locations] of Object.entries(fbtLocations)) {
           if (locations.length > 1) {
-            CompilerError.throwDiagnostic(
-              CompilerDiagnostic.fromCode(ErrorCode.TODO_DUPLICATE_FBT_TAGS, {
-                description: `Support \`<${tagName}>\` tags with multiple \`<${tagName}:${name}>\` values`,
-                details: locations.map(loc => {
-                  return {
-                    kind: 'error',
-                    message: `Multiple \`<${tagName}:${name}>\` tags found`,
-                    loc,
-                  };
-                }),
+            CompilerError.throwDiagnostic({
+              severity: ErrorSeverity.Todo,
+              category: ErrorCategory.FBT,
+              reason: 'Support duplicate fbt tags',
+              description: `Support \`<${tagName}>\` tags with multiple \`<${tagName}:${name}>\` values`,
+              details: locations.map(loc => {
+                return {
+                  kind: 'error',
+                  message: `Multiple \`<${tagName}:${name}>\` tags found`,
+                  loc,
+                };
               }),
-            );
+            });
           }
         }
       }
@@ -2330,6 +2392,7 @@ function lowerExpression(
           reason:
             '(BuildHIR::lowerExpression) Handle tagged template with interpolations',
           severity: ErrorSeverity.Todo,
+          category: ErrorCategory.Todo,
           loc: exprPath.node.loc ?? null,
           suggestions: null,
         });
@@ -2348,6 +2411,7 @@ function lowerExpression(
           reason:
             '(BuildHIR::lowerExpression) Handle tagged template where cooked value is different from raw value',
           severity: ErrorSeverity.Todo,
+          category: ErrorCategory.Todo,
           loc: exprPath.node.loc ?? null,
           suggestions: null,
         });
@@ -2367,8 +2431,12 @@ function lowerExpression(
       const quasis = expr.get('quasis');
 
       if (subexprs.length !== quasis.length - 1) {
-        builder.errors.pushErrorCode(ErrorCode.INVALID_QUASI_LENGTHS, {
+        builder.errors.push({
+          reason: `Unexpected quasi and subexpression lengths in template literal`,
+          severity: ErrorSeverity.InvalidJS,
+          category: ErrorCategory.Syntax,
           loc: exprPath.node.loc ?? null,
+          suggestions: null,
         });
         return {kind: 'UnsupportedNode', node: exprNode, loc: exprLoc};
       }
@@ -2377,6 +2445,7 @@ function lowerExpression(
         builder.errors.push({
           reason: `(BuildHIR::lowerAssignment) Handle TSType in TemplateLiteral.`,
           severity: ErrorSeverity.Todo,
+          category: ErrorCategory.Todo,
           loc: exprPath.node.loc ?? null,
           suggestions: null,
         });
@@ -2416,23 +2485,26 @@ function lowerExpression(
             };
           }
         } else {
-          builder.errors.pushErrorCode(
-            ErrorCode.INVALID_SYNTAX_DELETE_EXPRESSION,
-            {
-              loc: expr.node.loc ?? null,
-              suggestions: [
-                {
-                  description: 'Remove this line',
-                  range: [expr.node.start!, expr.node.end!],
-                  op: CompilerSuggestionOperation.Remove,
-                },
-              ],
-            },
-          );
+          builder.errors.push({
+            reason: `Only object properties can be deleted`,
+            severity: ErrorSeverity.InvalidJS,
+            category: ErrorCategory.Syntax,
+            loc: expr.node.loc ?? null,
+            suggestions: [
+              {
+                description: 'Remove this line',
+                range: [expr.node.start!, expr.node.end!],
+                op: CompilerSuggestionOperation.Remove,
+              },
+            ],
+          });
           return {kind: 'UnsupportedNode', node: expr.node, loc: exprLoc};
         }
       } else if (expr.node.operator === 'throw') {
-        builder.errors.pushErrorCode(ErrorCode.UNSUPPORTED_THROW_EXPRESSION, {
+        builder.errors.push({
+          reason: `Throw expressions are not supported`,
+          severity: ErrorSeverity.InvalidJS,
+          category: ErrorCategory.Syntax,
           loc: expr.node.loc ?? null,
           suggestions: [
             {
@@ -2554,6 +2626,7 @@ function lowerExpression(
         builder.errors.push({
           reason: `(BuildHIR::lowerExpression) Handle UpdateExpression with ${argument.type} argument`,
           severity: ErrorSeverity.Todo,
+          category: ErrorCategory.Todo,
           loc: exprPath.node.loc ?? null,
           suggestions: null,
         });
@@ -2562,6 +2635,7 @@ function lowerExpression(
         builder.errors.push({
           reason: `(BuildHIR::lowerExpression) Handle UpdateExpression to variables captured within lambdas.`,
           severity: ErrorSeverity.Todo,
+          category: ErrorCategory.Todo,
           loc: exprPath.node.loc ?? null,
           suggestions: null,
         });
@@ -2582,6 +2656,7 @@ function lowerExpression(
           builder.errors.push({
             reason: `(BuildHIR::lowerExpression) Found an invalid UpdateExpression without a previously reported error`,
             severity: ErrorSeverity.Invariant,
+            category: ErrorCategory.Invariant,
             loc: exprLoc,
             suggestions: null,
           });
@@ -2591,6 +2666,7 @@ function lowerExpression(
         builder.errors.push({
           reason: `(BuildHIR::lowerExpression) Support UpdateExpression where argument is a global`,
           severity: ErrorSeverity.Todo,
+          category: ErrorCategory.Todo,
           loc: exprLoc,
           suggestions: null,
         });
@@ -2646,6 +2722,7 @@ function lowerExpression(
       builder.errors.push({
         reason: `(BuildHIR::lowerExpression) Handle MetaProperty expressions other than import.meta`,
         severity: ErrorSeverity.Todo,
+        category: ErrorCategory.Todo,
         loc: exprPath.node.loc ?? null,
         suggestions: null,
       });
@@ -2655,6 +2732,7 @@ function lowerExpression(
       builder.errors.push({
         reason: `(BuildHIR::lowerExpression) Handle ${exprPath.type} expressions`,
         severity: ErrorSeverity.Todo,
+        category: ErrorCategory.Todo,
         loc: exprPath.node.loc ?? null,
         suggestions: null,
       });
@@ -2952,6 +3030,7 @@ function lowerReorderableExpression(
     builder.errors.push({
       reason: `(BuildHIR::node.lowerReorderableExpression) Expression type \`${expr.type}\` cannot be safely reordered`,
       severity: ErrorSeverity.Todo,
+      category: ErrorCategory.Todo,
       loc: expr.node.loc ?? null,
       suggestions: null,
     });
@@ -3148,6 +3227,7 @@ function lowerArguments(
       builder.errors.push({
         reason: `(BuildHIR::lowerExpression) Handle ${argPath.type} arguments in CallExpression`,
         severity: ErrorSeverity.Todo,
+        category: ErrorCategory.Todo,
         loc: argPath.node.loc ?? null,
         suggestions: null,
       });
@@ -3183,6 +3263,7 @@ function lowerMemberExpression(
       builder.errors.push({
         reason: `(BuildHIR::lowerMemberExpression) Handle ${propertyNode.type} property`,
         severity: ErrorSeverity.Todo,
+        category: ErrorCategory.Todo,
         loc: propertyNode.node.loc ?? null,
         suggestions: null,
       });
@@ -3204,6 +3285,7 @@ function lowerMemberExpression(
       builder.errors.push({
         reason: `(BuildHIR::lowerMemberExpression) Expected Expression, got ${propertyNode.type} property`,
         severity: ErrorSeverity.Todo,
+        category: ErrorCategory.Todo,
         loc: propertyNode.node.loc ?? null,
         suggestions: null,
       });
@@ -3259,8 +3341,11 @@ function lowerJsxElementName(
     const name = exprPath.node.name.name;
     const tag = `${namespace}:${name}`;
     if (namespace.indexOf(':') !== -1 || name.indexOf(':') !== -1) {
-      builder.errors.pushErrorCode(ErrorCode.INVALID_JSX_NAMESPACED_NAME, {
+      builder.errors.push({
+        reason: `Expected JSXNamespacedName to have no colons in the namespace or name`,
         description: `Got \`${namespace}\` : \`${name}\``,
+        severity: ErrorSeverity.InvalidJS,
+        category: ErrorCategory.Syntax,
         loc: exprPath.node.loc ?? null,
         suggestions: null,
       });
@@ -3275,6 +3360,7 @@ function lowerJsxElementName(
     builder.errors.push({
       reason: `(BuildHIR::lowerJsxElementName) Handle ${exprPath.type} tags`,
       severity: ErrorSeverity.Todo,
+      category: ErrorCategory.Todo,
       loc: exprPath.node.loc ?? null,
       suggestions: null,
     });
@@ -3373,6 +3459,7 @@ function lowerJsxElement(
     builder.errors.push({
       reason: `(BuildHIR::lowerJsxElement) Unhandled JsxElement, got: ${exprPath.type}`,
       severity: ErrorSeverity.Todo,
+      category: ErrorCategory.Todo,
       loc: exprPath.node.loc ?? null,
       suggestions: null,
     });
@@ -3555,7 +3642,12 @@ function lowerIdentifier(
     }
     default: {
       if (binding.kind === 'Global' && binding.name === 'eval') {
-        builder.errors.pushErrorCode(ErrorCode.UNSUPPORTED_EVAL, {
+        builder.errors.push({
+          reason: `The 'eval' function is not supported`,
+          description:
+            'Eval is an anti-pattern in JavaScript, and the code executed cannot be evaluated by React Compiler',
+          severity: ErrorSeverity.UnsupportedJS,
+          category: ErrorCategory.UnsupportedSyntax,
           loc: exprPath.node.loc ?? null,
           suggestions: null,
         });
@@ -3612,6 +3704,7 @@ function lowerIdentifierForAssignment(
       builder.errors.push({
         reason: `(BuildHIR::lowerAssignment) Could not find binding for declaration.`,
         severity: ErrorSeverity.Invariant,
+        category: ErrorCategory.Invariant,
         loc: path.node.loc ?? null,
         suggestions: null,
       });
@@ -3621,7 +3714,10 @@ function lowerIdentifierForAssignment(
     binding.bindingKind === 'const' &&
     kind === InstructionKind.Reassign
   ) {
-    builder.errors.pushErrorCode(ErrorCode.INVALID_SYNTAX_REASSIGNED_CONST, {
+    builder.errors.push({
+      reason: `Cannot reassign a \`const\` variable`,
+      severity: ErrorSeverity.InvalidJS,
+      category: ErrorCategory.Syntax,
       loc: path.node.loc ?? null,
       description:
         binding.identifier.name != null
@@ -3676,13 +3772,13 @@ function lowerAssignment(
       let temporary;
       if (builder.isContextIdentifier(lvalue)) {
         if (kind === InstructionKind.Const && !isHoistedIdentifier) {
-          builder.errors.pushErrorCode(
-            ErrorCode.INVALID_SYNTAX_REASSIGNED_CONST,
-            {
-              loc: lvalue.node.loc ?? null,
-              suggestions: null,
-            },
-          );
+          builder.errors.push({
+            reason: `Expected \`const\` declaration not to be reassigned`,
+            severity: ErrorSeverity.InvalidJS,
+            category: ErrorCategory.Syntax,
+            loc: lvalue.node.loc ?? null,
+            suggestions: null,
+          });
         }
 
         if (
@@ -3693,8 +3789,8 @@ function lowerAssignment(
         ) {
           builder.errors.push({
             reason: `Unexpected context variable kind`,
-            description: `Expected one of Const, Reassign, Let, Function, got ${kind}`,
-            severity: ErrorSeverity.Invariant,
+            severity: ErrorSeverity.InvalidJS,
+            category: ErrorCategory.Syntax,
             loc: lvalue.node.loc ?? null,
             suggestions: null,
           });
@@ -3766,6 +3862,7 @@ function lowerAssignment(
           builder.errors.push({
             reason: `(BuildHIR::lowerAssignment) Handle ${property.type} properties in MemberExpression`,
             severity: ErrorSeverity.Todo,
+            category: ErrorCategory.Todo,
             loc: property.node.loc ?? null,
             suggestions: null,
           });
@@ -3778,6 +3875,7 @@ function lowerAssignment(
             reason:
               '(BuildHIR::lowerAssignment) Expected private name to appear as a non-computed property',
             severity: ErrorSeverity.Todo,
+            category: ErrorCategory.Todo,
             loc: property.node.loc ?? null,
             suggestions: null,
           });
@@ -3843,6 +3941,7 @@ function lowerAssignment(
             } else if (identifier.kind === 'Global') {
               builder.errors.push({
                 severity: ErrorSeverity.Todo,
+                category: ErrorCategory.Todo,
                 reason:
                   'Expected reassignment of globals to enable forceTemporaries',
                 loc: element.node.loc ?? GeneratedSource,
@@ -3882,6 +3981,7 @@ function lowerAssignment(
           } else if (identifier.kind === 'Global') {
             builder.errors.push({
               severity: ErrorSeverity.Todo,
+              category: ErrorCategory.Todo,
               reason:
                 'Expected reassignment of globals to enable forceTemporaries',
               loc: element.node.loc ?? GeneratedSource,
@@ -3955,6 +4055,7 @@ function lowerAssignment(
             builder.errors.push({
               reason: `(BuildHIR::lowerAssignment) Handle ${argument.node.type} rest element in ObjectPattern`,
               severity: ErrorSeverity.Todo,
+              category: ErrorCategory.Todo,
               loc: argument.node.loc ?? null,
               suggestions: null,
             });
@@ -3986,6 +4087,7 @@ function lowerAssignment(
             } else if (identifier.kind === 'Global') {
               builder.errors.push({
                 severity: ErrorSeverity.Todo,
+                category: ErrorCategory.Todo,
                 reason:
                   'Expected reassignment of globals to enable forceTemporaries',
                 loc: property.node.loc ?? GeneratedSource,
@@ -4003,6 +4105,7 @@ function lowerAssignment(
             builder.errors.push({
               reason: `(BuildHIR::lowerAssignment) Handle ${property.type} properties in ObjectPattern`,
               severity: ErrorSeverity.Todo,
+              category: ErrorCategory.Todo,
               loc: property.node.loc ?? null,
               suggestions: null,
             });
@@ -4012,6 +4115,7 @@ function lowerAssignment(
             builder.errors.push({
               reason: `(BuildHIR::lowerAssignment) Handle computed properties in ObjectPattern`,
               severity: ErrorSeverity.Todo,
+              category: ErrorCategory.Todo,
               loc: property.node.loc ?? null,
               suggestions: null,
             });
@@ -4026,6 +4130,7 @@ function lowerAssignment(
             builder.errors.push({
               reason: `(BuildHIR::lowerAssignment) Expected object property value to be an LVal, got: ${element.type}`,
               severity: ErrorSeverity.Todo,
+              category: ErrorCategory.Todo,
               loc: element.node.loc ?? null,
               suggestions: null,
             });
@@ -4048,6 +4153,7 @@ function lowerAssignment(
             } else if (identifier.kind === 'Global') {
               builder.errors.push({
                 severity: ErrorSeverity.Todo,
+                category: ErrorCategory.Todo,
                 reason:
                   'Expected reassignment of globals to enable forceTemporaries',
                 loc: element.node.loc ?? GeneratedSource,
@@ -4197,6 +4303,7 @@ function lowerAssignment(
       builder.errors.push({
         reason: `(BuildHIR::lowerAssignment) Handle ${lvaluePath.type} assignments`,
         severity: ErrorSeverity.Todo,
+        category: ErrorCategory.Todo,
         loc: lvaluePath.node.loc ?? null,
         suggestions: null,
       });

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

@@ -93,7 +93,7 @@ export const MacroSchema = z.union([
   z.tuple([z.string(), z.array(MacroMethodSchema)]),
 ]);
 
-export type CompilerMode = 'all_features' | 'no_inferred_memo' | 'lint_only';
+export type CompilerMode = 'all_features' | 'no_inferred_memo';
 
 export type Macro = z.infer<typeof MacroSchema>;
 export type MacroMethod = z.infer<typeof MacroMethodSchema>;
@@ -250,11 +250,6 @@ export const EnvironmentConfigSchema = z.object({
    */
   flowTypeProvider: z.nullable(z.function().args(z.string())).default(null),
 
-  /**
-   * Enable a new model for mutability and aliasing inference
-   */
-  enableNewMutationAliasingModel: z.boolean().default(true),
-
   /**
    * Enables inference of optional dependency chains. Without this flag
    * a property chain such as `props?.items?.foo` will infer as a dep on
@@ -829,14 +824,6 @@ export class Environment {
     }
   }
 
-  logOrThrowErrors(errors: Result<void, CompilerError>): void {
-    if (this.compilerMode === 'lint_only') {
-      this.logErrors(errors);
-    } else {
-      errors.unwrap();
-    }
-  }
-
   isContextIdentifier(node: t.Identifier): boolean {
     return this.#contextIdentifiers.has(node);
   }

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

@@ -7,7 +7,7 @@
 
 import {BindingKind} from '@babel/traverse';
 import * as t from '@babel/types';
-import {CompilerError, CompilerErrorDetailOptions} from '../CompilerError';
+import {CompilerError} from '../CompilerError';
 import {assertExhaustive} from '../Utils/utils';
 import {Environment, ReactFunctionType} from './Environment';
 import type {HookKind} from './ObjectShape';
@@ -15,7 +15,6 @@ import {Type, makeType} from './Types';
 import {z} from 'zod';
 import type {AliasingEffect} from '../Inference/AliasingEffects';
 import {isReservedWord} from '../Utils/Keyword';
-import {ErrorCode} from '../Utils/CompilerErrorCodes';
 
 /*
  * *******************************************************************************************
@@ -283,30 +282,13 @@ export type HIRFunction = {
   returnTypeAnnotation: t.FlowType | t.TSType | null;
   returns: Place;
   context: Array<Place>;
-  effects: Array<FunctionEffect> | null;
   body: HIR;
   generator: boolean;
   async: boolean;
   directives: Array<string>;
-  aliasingEffects?: Array<AliasingEffect> | null;
+  aliasingEffects: Array<AliasingEffect> | null;
 };
 
-export type FunctionEffect =
-  | {
-      kind: 'GlobalMutation';
-      error: CompilerErrorDetailOptions;
-    }
-  | {
-      kind: 'ReactMutation';
-      error: CompilerErrorDetailOptions;
-    }
-  | {
-      kind: 'ContextMutation';
-      places: ReadonlySet<Place>;
-      effect: Effect;
-      loc: SourceLocation;
-    };
-
 /*
  * Each reactive scope may have its own control-flow, so the instructions form
  * a control-flow graph. The graph comprises a set of basic blocks which reference
@@ -1323,18 +1305,18 @@ export function forkTemporaryIdentifier(
  */
 export function makeIdentifierName(name: string): ValidatedIdentifier {
   if (isReservedWord(name)) {
-    CompilerError.throwFromCode(
-      ErrorCode.INVALID_SYNTAX_RESERVED_VARIABLE_NAME,
-      {
-        loc: GeneratedSource,
-        description: `\`${name}\` is a reserved word in JavaScript and cannot be used as an identifier name`,
-      },
-    );
+    CompilerError.throwInvalidJS({
+      reason: 'Expected a non-reserved identifier name',
+      loc: GeneratedSource,
+      description: `\`${name}\` is a reserved word in JavaScript and cannot be used as an identifier name`,
+      suggestions: null,
+    });
   } else {
     CompilerError.invariant(t.isValidIdentifier(name), {
       reason: `Expected a valid identifier name`,
       loc: GeneratedSource,
       description: `\`${name}\` is not a valid JavaScript identifier`,
+      suggestions: null,
     });
   }
   return {

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

@@ -7,7 +7,7 @@
 
 import {Binding, NodePath} from '@babel/traverse';
 import * as t from '@babel/types';
-import {CompilerDiagnostic, CompilerError} from '../CompilerError';
+import {CompilerError, ErrorCategory, ErrorSeverity} from '../CompilerError';
 import {Environment} from './Environment';
 import {
   BasicBlock,
@@ -37,7 +37,6 @@ import {
   mapTerminalSuccessors,
   terminalFallthrough,
 } from './visitors';
-import {ErrorCode} from '../Utils/CompilerErrorCodes';
 
 /*
  * *******************************************************************************************
@@ -309,17 +308,20 @@ export default class HIRBuilder {
 
   resolveBinding(node: t.Identifier): Identifier {
     if (node.name === 'fbt') {
-      CompilerError.throwDiagnostic(
-        CompilerDiagnostic.fromCode(ErrorCode.TODO_CONFLICTING_FBT_IDENTIFIER, {
-          details: [
-            {
-              kind: 'error',
-              message: 'Rename to avoid conflict with fbt plugin',
-              loc: node.loc ?? GeneratedSource,
-            },
-          ],
-        }),
-      );
+      CompilerError.throwDiagnostic({
+        severity: ErrorSeverity.Todo,
+        category: ErrorCategory.FBT,
+        reason: 'Support local variables named `fbt`',
+        description:
+          'Local variables named `fbt` may conflict with the fbt plugin and are not yet supported',
+        details: [
+          {
+            kind: 'error',
+            message: 'Rename to avoid conflict with fbt plugin',
+            loc: node.loc ?? GeneratedSource,
+          },
+        ],
+      });
     }
     const originalName = node.name;
     let name = originalName;

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

@@ -554,23 +554,11 @@ export function printInstructionValue(instrValue: ReactiveValue): string {
       const context = instrValue.loweredFunc.func.context
         .map(dep => printPlace(dep))
         .join(',');
-      const effects =
-        instrValue.loweredFunc.func.effects
-          ?.map(effect => {
-            if (effect.kind === 'ContextMutation') {
-              return `ContextMutation places=[${[...effect.places]
-                .map(place => printPlace(place))
-                .join(', ')}] effect=${effect.effect}`;
-            } else {
-              return `GlobalMutation`;
-            }
-          })
-          .join(', ') ?? '';
       const aliasingEffects =
         instrValue.loweredFunc.func.aliasingEffects
           ?.map(printAliasingEffect)
           ?.join(', ') ?? '';
-      value = `${kind} ${name} @context[${context}] @effects[${effects}] @aliasingEffects=[${aliasingEffects}]\n${fn}`;
+      value = `${kind} ${name} @context[${context}] @aliasingEffects=[${aliasingEffects}]\n${fn}`;
       break;
     }
     case 'TaggedTemplateExpression': {
@@ -998,13 +986,13 @@ export function printAliasingEffect(effect: AliasingEffect): string {
       return `${effect.kind} ${printPlaceForAliasEffect(effect.value)}`;
     }
     case 'MutateFrozen': {
-      return `MutateFrozen ${printPlaceForAliasEffect(effect.place)} reason=${JSON.stringify(effect.error.category)}`;
+      return `MutateFrozen ${printPlaceForAliasEffect(effect.place)} reason=${JSON.stringify(effect.error.reason)}`;
     }
     case 'MutateGlobal': {
-      return `MutateGlobal ${printPlaceForAliasEffect(effect.place)} reason=${JSON.stringify(effect.error.category)}`;
+      return `MutateGlobal ${printPlaceForAliasEffect(effect.place)} reason=${JSON.stringify(effect.error.reason)}`;
     }
     case 'Impure': {
-      return `Impure ${printPlaceForAliasEffect(effect.place)} reason=${JSON.stringify(effect.error.category)}`;
+      return `Impure ${printPlaceForAliasEffect(effect.place)} reason=${JSON.stringify(effect.error.reason)}`;
     }
     case 'Render': {
       return `Render ${printPlaceForAliasEffect(effect.place)}`;

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

@@ -50,7 +50,7 @@ export type AliasingEffect =
   /**
    * Mutate the value and any direct aliases (not captures). Errors if the value is not mutable.
    */
-  | {kind: 'Mutate'; value: Place}
+  | {kind: 'Mutate'; value: Place; reason?: MutationReason | null}
   /**
    * Mutate the value and any direct aliases (not captures), but only if the value is known mutable.
    * This should be rare.
@@ -174,6 +174,8 @@ export type AliasingEffect =
       place: Place;
     };
 
+export type MutationReason = {kind: 'AssignCurrentProperty'};
+
 export function hashEffect(effect: AliasingEffect): string {
   switch (effect.kind) {
     case 'Apply': {
@@ -229,7 +231,7 @@ export function hashEffect(effect: AliasingEffect): string {
         effect.kind,
         effect.place.identifier.id,
         effect.error.severity,
-        effect.error.category,
+        effect.error.reason,
         effect.error.description,
         printSourceLocation(effect.error.primaryLocation() ?? GeneratedSource),
       ].join(':');

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

@@ -6,20 +6,10 @@
  */
 
 import {CompilerError} from '../CompilerError';
-import {
-  Effect,
-  HIRFunction,
-  Identifier,
-  IdentifierId,
-  LoweredFunction,
-  isRefOrRefValue,
-  makeInstructionId,
-} from '../HIR';
+import {Effect, HIRFunction, IdentifierId, makeInstructionId} from '../HIR';
 import {deadCodeElimination} from '../Optimization';
 import {inferReactiveScopeVariables} from '../ReactiveScopes';
 import {rewriteInstructionKindsBasedOnReassignment} from '../SSA';
-import {inferMutableRanges} from './InferMutableRanges';
-import inferReferenceEffects from './InferReferenceEffects';
 import {assertExhaustive} from '../Utils/utils';
 import {inferMutationAliasingEffects} from './InferMutationAliasingEffects';
 import {inferMutationAliasingRanges} from './InferMutationAliasingRanges';
@@ -30,12 +20,7 @@ export default function analyseFunctions(func: HIRFunction): void {
       switch (instr.value.kind) {
         case 'ObjectMethod':
         case 'FunctionExpression': {
-          if (!func.env.config.enableNewMutationAliasingModel) {
-            lower(instr.value.loweredFunc.func);
-            infer(instr.value.loweredFunc);
-          } else {
-            lowerWithMutationAliasing(instr.value.loweredFunc.func);
-          }
+          lowerWithMutationAliasing(instr.value.loweredFunc.func);
 
           /**
            * Reset mutable range for outer inferReferenceEffects
@@ -140,58 +125,3 @@ function lowerWithMutationAliasing(fn: HIRFunction): void {
     value: fn,
   });
 }
-
-function lower(func: HIRFunction): void {
-  analyseFunctions(func);
-  inferReferenceEffects(func, {isFunctionExpression: true});
-  deadCodeElimination(func);
-  inferMutableRanges(func);
-  rewriteInstructionKindsBasedOnReassignment(func);
-  inferReactiveScopeVariables(func);
-  func.env.logger?.debugLogIRs?.({
-    kind: 'hir',
-    name: 'AnalyseFunction (inner)',
-    value: func,
-  });
-}
-
-function infer(loweredFunc: LoweredFunction): void {
-  for (const operand of loweredFunc.func.context) {
-    const identifier = operand.identifier;
-    CompilerError.invariant(operand.effect === Effect.Unknown, {
-      reason:
-        '[AnalyseFunctions] Expected Function context effects to not have been set',
-      loc: operand.loc,
-    });
-    if (isRefOrRefValue(identifier)) {
-      /*
-       * TODO: this is a hack to ensure we treat functions which reference refs
-       * as having a capture and therefore being considered mutable. this ensures
-       * the function gets a mutable range which accounts for anywhere that it
-       * could be called, and allows us to help ensure it isn't called during
-       * render
-       */
-      operand.effect = Effect.Capture;
-    } else if (isMutatedOrReassigned(identifier)) {
-      /**
-       * Reflects direct reassignments, PropertyStores, and ConditionallyMutate
-       * (directly or through maybe-aliases)
-       */
-      operand.effect = Effect.Capture;
-    } else {
-      operand.effect = Effect.Read;
-    }
-  }
-}
-
-function isMutatedOrReassigned(id: Identifier): boolean {
-  /*
-   * This check checks for mutation and reassingnment, so the usual check for
-   * mutation (ie, `mutableRange.end - mutableRange.start > 1`) isn't quite
-   * enough.
-   *
-   * We need to track re-assignments in context refs as we need to reflect the
-   * re-assignment back to the captured refs.
-   */
-  return id.mutableRange.end > id.mutableRange.start;
-}

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

@@ -5,7 +5,13 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-import {CompilerDiagnostic, CompilerError, SourceLocation} from '..';
+import {
+  CompilerDiagnostic,
+  CompilerError,
+  ErrorSeverity,
+  SourceLocation,
+} from '..';
+import {ErrorCategory} from '../CompilerError';
 import {
   CallExpression,
   Effect,
@@ -30,7 +36,6 @@ import {
   makeInstructionId,
 } from '../HIR';
 import {createTemporaryPlace, markInstructionIds} from '../HIR/HIRBuilder';
-import {ErrorCode} from '../Utils/CompilerErrorCodes';
 import {Result} from '../Utils/Result';
 
 type ManualMemoCallee = {
@@ -295,11 +300,13 @@ function extractManualMemoizationArgs(
   >;
   if (fnPlace == null) {
     errors.pushDiagnostic(
-      CompilerDiagnostic.fromCode(
-        kind === 'useMemo'
-          ? ErrorCode.INVALID_USE_MEMO_NO_ARG0
-          : ErrorCode.INVALID_USE_CALLBACK_NO_ARG0,
-      ).withDetail({
+      CompilerDiagnostic.create({
+        category: ErrorCategory.UseMemo,
+        severity: ErrorSeverity.InvalidReact,
+        reason: `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}`,
@@ -309,11 +316,13 @@ function extractManualMemoizationArgs(
   }
   if (fnPlace.kind === 'Spread' || depsListPlace?.kind === 'Spread') {
     errors.pushDiagnostic(
-      CompilerDiagnostic.fromCode(
-        fnPlace.kind === 'Spread'
-          ? ErrorCode.DYNAMIC_USE_MEMO_SPREAD_ARGUMENT
-          : ErrorCode.DYNAMIC_USE_CALLBACK_SPREAD_ARGUMENT,
-      ).withDetail({
+      CompilerDiagnostic.create({
+        category: ErrorCategory.UseMemo,
+        severity: ErrorSeverity.InvalidReact,
+        reason: `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}`,
@@ -328,9 +337,13 @@ function extractManualMemoizationArgs(
     );
     if (maybeDepsList == null) {
       errors.pushDiagnostic(
-        CompilerDiagnostic.fromCode(
-          ErrorCode.DYNAMIC_MANUAL_MEMO_DEPENDENCY_LIST,
-        ).withDetail({
+        CompilerDiagnostic.create({
+          category: ErrorCategory.UseMemo,
+          severity: ErrorSeverity.InvalidReact,
+          reason: `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`,
@@ -343,9 +356,13 @@ function extractManualMemoizationArgs(
       const maybeDep = sidemap.maybeDeps.get(dep.identifier.id);
       if (maybeDep == null) {
         errors.pushDiagnostic(
-          CompilerDiagnostic.fromCode(
-            ErrorCode.COMPLEX_MANUAL_MEMO_DEPENDENCY_LIST_ENTRY,
-          ).withDetail({
+          CompilerDiagnostic.create({
+            category: ErrorCategory.UseMemo,
+            severity: ErrorSeverity.InvalidReact,
+            reason: `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\`)`,
@@ -445,16 +462,17 @@ export function dropManualMemoization(
             if (funcToCheck !== undefined && funcToCheck.loweredFunc.func) {
               if (!hasNonVoidReturn(funcToCheck.loweredFunc.func)) {
                 errors.pushDiagnostic(
-                  CompilerDiagnostic.fromCode(
-                    ErrorCode.INVALID_USE_MEMO_CALLBACK_RETURN,
-                    {
-                      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.`,
-                    },
-                  ).withDetail({
+                  CompilerDiagnostic.create({
+                    severity: ErrorSeverity.InvalidReact,
+                    category: ErrorCategory.UseMemo,
+                    reason: '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',
@@ -485,9 +503,13 @@ export function dropManualMemoization(
              */
             if (!sidemap.functions.has(fnPlace.identifier.id)) {
               errors.pushDiagnostic(
-                CompilerDiagnostic.fromCode(
-                  ErrorCode.DYNAMIC_MANUAL_MEMO_CALLBACK,
-                ).withDetail({
+                CompilerDiagnostic.create({
+                  category: ErrorCategory.UseMemo,
+                  severity: ErrorSeverity.InvalidReact,
+                  reason: `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`,

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

@@ -1,134 +0,0 @@
-/**
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-import {
-  Effect,
-  HIRFunction,
-  Identifier,
-  isMutableEffect,
-  isRefOrRefLikeMutableType,
-  makeInstructionId,
-} from '../HIR/HIR';
-import {eachInstructionValueOperand} from '../HIR/visitors';
-import {isMutable} from '../ReactiveScopes/InferReactiveScopeVariables';
-import DisjointSet from '../Utils/DisjointSet';
-
-/**
- * If a function captures a mutable value but never gets called, we don't infer a
- * mutable range for that function. This means that we also don't alias the function
- * with its mutable captures.
- *
- * This case is tricky, because we don't generally know for sure what is a mutation
- * and what may just be a normal function call. For example:
- *
- * ```
- * hook useFoo() {
- *   const x = makeObject();
- *   return () => {
- *     return readObject(x); // could be a mutation!
- *   }
- * }
- * ```
- *
- * If we pessimistically assume that all such cases are mutations, we'd have to group
- * lots of memo scopes together unnecessarily. However, if there is definitely a mutation:
- *
- * ```
- * hook useFoo(createEntryForKey) {
- *   const cache = new WeakMap();
- *   return (key) => {
- *     let entry = cache.get(key);
- *     if (entry == null) {
- *       entry = createEntryForKey(key);
- *       cache.set(key, entry); // known mutation!
- *     }
- *     return entry;
- *   }
- * }
- * ```
- *
- * Then we have to ensure that the function and its mutable captures alias together and
- * end up in the same scope. However, aliasing together isn't enough if the function
- * and operands all have empty mutable ranges (end = start + 1).
- *
- * This pass finds function expressions and object methods that have an empty mutable range
- * and known-mutable operands which also don't have a mutable range, and ensures that the
- * function and those operands are aliased together *and* that their ranges are updated to
- * end after the function expression. This is sufficient to ensure that a reactive scope is
- * created for the alias set.
- */
-export function inferAliasForUncalledFunctions(
-  fn: HIRFunction,
-  aliases: DisjointSet<Identifier>,
-): void {
-  for (const block of fn.body.blocks.values()) {
-    instrs: for (const instr of block.instructions) {
-      const {lvalue, value} = instr;
-      if (
-        value.kind !== 'ObjectMethod' &&
-        value.kind !== 'FunctionExpression'
-      ) {
-        continue;
-      }
-      /*
-       * If the function is known to be mutated, we will have
-       * already aliased any mutable operands with it
-       */
-      const range = lvalue.identifier.mutableRange;
-      if (range.end > range.start + 1) {
-        continue;
-      }
-      /*
-       * If the function already has operands with an active mutable range,
-       * then we don't need to do anything — the function will have already
-       * been visited and included in some mutable alias set. This case can
-       * also occur due to visiting the same function in an earlier iteration
-       * of the outer fixpoint loop.
-       */
-      for (const operand of eachInstructionValueOperand(value)) {
-        if (isMutable(instr, operand)) {
-          continue instrs;
-        }
-      }
-      const operands: Set<Identifier> = new Set();
-      for (const effect of value.loweredFunc.func.effects ?? []) {
-        if (effect.kind !== 'ContextMutation') {
-          continue;
-        }
-        /*
-         * We're looking for known-mutations only, so we look at the effects
-         * rather than function context
-         */
-        if (effect.effect === Effect.Store || effect.effect === Effect.Mutate) {
-          for (const operand of effect.places) {
-            /*
-             * It's possible that function effect analysis thinks there was a context mutation,
-             * but then InferReferenceEffects figures out some operands are globals and therefore
-             * creates a non-mutable effect for those operands.
-             * We should change InferReferenceEffects to swap the ContextMutation for a global
-             * mutation in that case, but for now we just filter them out here
-             */
-            if (
-              isMutableEffect(operand.effect, operand.loc) &&
-              !isRefOrRefLikeMutableType(operand.identifier.type)
-            ) {
-              operands.add(operand.identifier);
-            }
-          }
-        }
-      }
-      if (operands.size !== 0) {
-        operands.add(lvalue.identifier);
-        aliases.union([...operands]);
-        // Update mutable ranges, if the ranges are empty then a reactive scope isn't created
-        for (const operand of operands) {
-          operand.mutableRange.end = makeInstructionId(instr.id + 1);
-        }
-      }
-    }
-  }
-}

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

@@ -1,68 +0,0 @@
-/**
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-import {
-  HIRFunction,
-  Identifier,
-  Instruction,
-  isPrimitiveType,
-  Place,
-} from '../HIR/HIR';
-import DisjointSet from '../Utils/DisjointSet';
-
-export type AliasSet = Set<Identifier>;
-
-export function inferAliases(func: HIRFunction): DisjointSet<Identifier> {
-  const aliases = new DisjointSet<Identifier>();
-  for (const [_, block] of func.body.blocks) {
-    for (const instr of block.instructions) {
-      inferInstr(instr, aliases);
-    }
-  }
-
-  return aliases;
-}
-
-function inferInstr(
-  instr: Instruction,
-  aliases: DisjointSet<Identifier>,
-): void {
-  const {lvalue, value: instrValue} = instr;
-  let alias: Place | null = null;
-  switch (instrValue.kind) {
-    case 'LoadLocal':
-    case 'LoadContext': {
-      if (isPrimitiveType(instrValue.place.identifier)) {
-        return;
-      }
-      alias = instrValue.place;
-      break;
-    }
-    case 'StoreLocal':
-    case 'StoreContext': {
-      alias = instrValue.value;
-      break;
-    }
-    case 'Destructure': {
-      alias = instrValue.value;
-      break;
-    }
-    case 'ComputedLoad':
-    case 'PropertyLoad': {
-      alias = instrValue.object;
-      break;
-    }
-    case 'TypeCastExpression': {
-      alias = instrValue.value;
-      break;
-    }
-    default:
-      return;
-  }
-
-  aliases.union([lvalue.identifier, alias.identifier]);
-}

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

@@ -1,27 +0,0 @@
-/**
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-import {HIRFunction, Identifier} from '../HIR/HIR';
-import DisjointSet from '../Utils/DisjointSet';
-
-export function inferAliasForPhis(
-  func: HIRFunction,
-  aliases: DisjointSet<Identifier>,
-): void {
-  for (const [_, block] of func.body.blocks) {
-    for (const phi of block.phis) {
-      const isPhiMutatedAfterCreation: boolean =
-        phi.place.identifier.mutableRange.end >
-        (block.instructions.at(0)?.id ?? block.terminal.id);
-      if (isPhiMutatedAfterCreation) {
-        for (const [, operand] of phi.operands) {
-          aliases.union([phi.place.identifier, operand.identifier]);
-        }
-      }
-    }
-  }
-}

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

@@ -1,68 +0,0 @@
-/**
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-import {
-  Effect,
-  HIRFunction,
-  Identifier,
-  InstructionId,
-  Place,
-} from '../HIR/HIR';
-import {
-  eachInstructionLValue,
-  eachInstructionValueOperand,
-} from '../HIR/visitors';
-import DisjointSet from '../Utils/DisjointSet';
-
-export function inferAliasForStores(
-  func: HIRFunction,
-  aliases: DisjointSet<Identifier>,
-): void {
-  for (const [_, block] of func.body.blocks) {
-    for (const instr of block.instructions) {
-      const {value, lvalue} = instr;
-      const isStore =
-        lvalue.effect === Effect.Store ||
-        /*
-         * Some typed functions annotate callees or arguments
-         * as Effect.Store.
-         */
-        ![...eachInstructionValueOperand(value)].every(
-          operand => operand.effect !== Effect.Store,
-        );
-
-      if (!isStore) {
-        continue;
-      }
-      for (const operand of eachInstructionLValue(instr)) {
-        maybeAlias(aliases, lvalue, operand, instr.id);
-      }
-      for (const operand of eachInstructionValueOperand(value)) {
-        if (
-          operand.effect === Effect.Capture ||
-          operand.effect === Effect.Store
-        ) {
-          maybeAlias(aliases, lvalue, operand, instr.id);
-        }
-      }
-    }
-  }
-}
-
-function maybeAlias(
-  aliases: DisjointSet<Identifier>,
-  lvalue: Place,
-  rvalue: Place,
-  id: InstructionId,
-): void {
-  if (
-    lvalue.identifier.mutableRange.end > id + 1 ||
-    rvalue.identifier.mutableRange.end > id
-  ) {
-    aliases.union([lvalue.identifier, rvalue.identifier]);
-  }
-}

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

@@ -1,347 +0,0 @@
-/**
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-import {
-  CompilerError,
-  CompilerErrorDetailOptions,
-  ErrorSeverity,
-  ValueKind,
-} from '..';
-import {
-  AbstractValue,
-  BasicBlock,
-  Effect,
-  Environment,
-  FunctionEffect,
-  Instruction,
-  InstructionValue,
-  Place,
-  ValueReason,
-  getHookKind,
-  isRefOrRefValue,
-} from '../HIR';
-import {eachInstructionOperand, eachTerminalOperand} from '../HIR/visitors';
-import {ErrorCode} from '../Utils/CompilerErrorCodes';
-import {assertExhaustive} from '../Utils/utils';
-
-interface State {
-  kind(place: Place): AbstractValue;
-  values(place: Place): Array<InstructionValue>;
-  isDefined(place: Place): boolean;
-}
-
-function inferOperandEffect(state: State, place: Place): null | FunctionEffect {
-  const value = state.kind(place);
-  CompilerError.invariant(value != null, {
-    reason: 'Expected operand to have a kind',
-    loc: null,
-  });
-
-  switch (place.effect) {
-    case Effect.Store:
-    case Effect.Mutate: {
-      if (isRefOrRefValue(place.identifier)) {
-        break;
-      } else if (value.kind === ValueKind.Context) {
-        CompilerError.invariant(value.context.size > 0, {
-          reason:
-            "[InferFunctionEffects] Expected Context-kind value's capture list to be non-empty.",
-          loc: place.loc,
-        });
-        return {
-          kind: 'ContextMutation',
-          loc: place.loc,
-          effect: place.effect,
-          places: value.context,
-        };
-      } else if (
-        value.kind !== ValueKind.Mutable &&
-        // We ignore mutations of primitives since this is not a React-specific problem
-        value.kind !== ValueKind.Primitive
-      ) {
-        let errorCode = getWriteErrorReason(value);
-        return {
-          kind:
-            value.reason.size === 1 && value.reason.has(ValueReason.Global)
-              ? 'GlobalMutation'
-              : 'ReactMutation',
-          error: {
-            errorCode,
-            description:
-              place.identifier.name !== null &&
-              place.identifier.name.kind === 'named'
-                ? `Found mutation of \`${place.identifier.name.value}\``
-                : null,
-            loc: place.loc,
-          },
-        };
-      }
-      break;
-    }
-  }
-  return null;
-}
-
-function inheritFunctionEffects(
-  state: State,
-  place: Place,
-): Array<FunctionEffect> {
-  const effects = inferFunctionInstrEffects(state, place);
-
-  return effects
-    .flatMap(effect => {
-      if (effect.kind === 'GlobalMutation' || effect.kind === 'ReactMutation') {
-        return [effect];
-      } else {
-        const effects: Array<FunctionEffect | null> = [];
-        CompilerError.invariant(effect.kind === 'ContextMutation', {
-          reason: 'Expected ContextMutation',
-          loc: null,
-        });
-        /**
-         * Contextual effects need to be replayed against the current inference
-         * state, which may know more about the value to which the effect applied.
-         * The main cases are:
-         * 1. The mutated context value is _still_ a context value in the current scope,
-         *    so we have to continue propagating the original context mutation.
-         * 2. The mutated context value is a mutable value in the current scope,
-         *    so the context mutation was fine and we can skip propagating the effect.
-         * 3. The mutated context value  is an immutable value in the current scope,
-         *    resulting in a non-ContextMutation FunctionEffect. We propagate that new,
-         *    more detailed effect to the current function context.
-         */
-        for (const place of effect.places) {
-          if (state.isDefined(place)) {
-            const replayedEffect = inferOperandEffect(state, {
-              ...place,
-              loc: effect.loc,
-              effect: effect.effect,
-            });
-            if (replayedEffect != null) {
-              if (replayedEffect.kind === 'ContextMutation') {
-                // Case 1, still a context value so propagate the original effect
-                effects.push(effect);
-              } else {
-                // Case 3, immutable value so propagate the more precise effect
-                effects.push(replayedEffect);
-              }
-            } // else case 2, local mutable value so this effect was fine
-          }
-        }
-        return effects;
-      }
-    })
-    .filter((effect): effect is FunctionEffect => effect != null);
-}
-
-function inferFunctionInstrEffects(
-  state: State,
-  place: Place,
-): Array<FunctionEffect> {
-  const effects: Array<FunctionEffect> = [];
-  const instrs = state.values(place);
-  CompilerError.invariant(instrs != null, {
-    reason: 'Expected operand to have instructions',
-    loc: null,
-  });
-
-  for (const instr of instrs) {
-    if (
-      (instr.kind === 'FunctionExpression' || instr.kind === 'ObjectMethod') &&
-      instr.loweredFunc.func.effects != null
-    ) {
-      effects.push(...instr.loweredFunc.func.effects);
-    }
-  }
-
-  return effects;
-}
-
-function operandEffects(
-  state: State,
-  place: Place,
-  filterRenderSafe: boolean,
-): Array<FunctionEffect> {
-  const functionEffects: Array<FunctionEffect> = [];
-  const effect = inferOperandEffect(state, place);
-  effect && functionEffects.push(effect);
-  functionEffects.push(...inheritFunctionEffects(state, place));
-  if (filterRenderSafe) {
-    return functionEffects.filter(effect => !isEffectSafeOutsideRender(effect));
-  } else {
-    return functionEffects;
-  }
-}
-
-export function inferInstructionFunctionEffects(
-  env: Environment,
-  state: State,
-  instr: Instruction,
-): Array<FunctionEffect> {
-  const functionEffects: Array<FunctionEffect> = [];
-  switch (instr.value.kind) {
-    case 'JsxExpression': {
-      if (instr.value.tag.kind === 'Identifier') {
-        functionEffects.push(...operandEffects(state, instr.value.tag, false));
-      }
-      instr.value.children?.forEach(child =>
-        functionEffects.push(...operandEffects(state, child, false)),
-      );
-      for (const attr of instr.value.props) {
-        if (attr.kind === 'JsxSpreadAttribute') {
-          functionEffects.push(...operandEffects(state, attr.argument, false));
-        } else {
-          functionEffects.push(...operandEffects(state, attr.place, true));
-        }
-      }
-      break;
-    }
-    case 'ObjectMethod':
-    case 'FunctionExpression': {
-      /**
-       * If this function references other functions, propagate the referenced function's
-       * effects to this function.
-       *
-       * ```
-       * let f = () => global = true;
-       * let g = () => f();
-       * g();
-       * ```
-       *
-       * In this example, because `g` references `f`, we propagate the GlobalMutation from
-       * `f` to `g`. Thus, referencing `g` in `g()` will evaluate the GlobalMutation in the outer
-       * function effect context and report an error. But if instead we do:
-       *
-       * ```
-       * let f = () => global = true;
-       * let g = () => f();
-       * useEffect(() => g(), [g])
-       * ```
-       *
-       * Now `g`'s effects will be discarded since they're in a useEffect.
-       */
-      for (const operand of eachInstructionOperand(instr)) {
-        instr.value.loweredFunc.func.effects ??= [];
-        instr.value.loweredFunc.func.effects.push(
-          ...inferFunctionInstrEffects(state, operand),
-        );
-      }
-      break;
-    }
-    case 'MethodCall':
-    case 'CallExpression': {
-      let callee;
-      if (instr.value.kind === 'MethodCall') {
-        callee = instr.value.property;
-        functionEffects.push(
-          ...operandEffects(state, instr.value.receiver, false),
-        );
-      } else {
-        callee = instr.value.callee;
-      }
-      functionEffects.push(...operandEffects(state, callee, false));
-      let isHook = getHookKind(env, callee.identifier) != null;
-      for (const arg of instr.value.args) {
-        const place = arg.kind === 'Identifier' ? arg : arg.place;
-        /*
-         * Join the effects of the argument with the effects of the enclosing function,
-         * unless the we're detecting a global mutation inside a useEffect hook
-         */
-        functionEffects.push(...operandEffects(state, place, isHook));
-      }
-      break;
-    }
-    case 'StartMemoize':
-    case 'FinishMemoize':
-    case 'LoadLocal':
-    case 'StoreLocal': {
-      break;
-    }
-    case 'StoreGlobal': {
-      functionEffects.push({
-        kind: 'GlobalMutation',
-        error: {
-          errorCode: ErrorCode.INVALID_WRITE_GLOBAL,
-          loc: instr.loc,
-        },
-      });
-      break;
-    }
-    default: {
-      for (const operand of eachInstructionOperand(instr)) {
-        functionEffects.push(...operandEffects(state, operand, false));
-      }
-    }
-  }
-  return functionEffects;
-}
-
-export function inferTerminalFunctionEffects(
-  state: State,
-  block: BasicBlock,
-): Array<FunctionEffect> {
-  const functionEffects: Array<FunctionEffect> = [];
-  for (const operand of eachTerminalOperand(block.terminal)) {
-    functionEffects.push(...operandEffects(state, operand, true));
-  }
-  return functionEffects;
-}
-
-export function transformFunctionEffectErrors(
-  functionEffects: Array<FunctionEffect>,
-): Array<CompilerErrorDetailOptions> {
-  return functionEffects.map(eff => {
-    switch (eff.kind) {
-      case 'ReactMutation':
-      case 'GlobalMutation': {
-        return eff.error;
-      }
-      case 'ContextMutation': {
-        return {
-          severity: ErrorSeverity.Invariant,
-          reason: `Unexpected ContextMutation in top-level function effects`,
-          loc: eff.loc,
-        };
-      }
-      default:
-        assertExhaustive(
-          eff,
-          `Unexpected function effect kind \`${(eff as any).kind}\``,
-        );
-    }
-  });
-}
-
-function isEffectSafeOutsideRender(effect: FunctionEffect): boolean {
-  return effect.kind === 'GlobalMutation';
-}
-
-export function getWriteErrorReason(abstractValue: AbstractValue): ErrorCode {
-  if (abstractValue.reason.has(ValueReason.Global)) {
-    return ErrorCode.INVALID_WRITE_GLOBAL;
-  } else if (abstractValue.reason.has(ValueReason.JsxCaptured)) {
-    return ErrorCode.INVALID_WRITE_FROZEN_VALUE_JSX;
-  } else if (abstractValue.reason.has(ValueReason.Context)) {
-    return ErrorCode.INVALID_WRITE_IMMUTABLE_VALUE_USE_CONTEXT;
-  } else if (abstractValue.reason.has(ValueReason.KnownReturnSignature)) {
-    return ErrorCode.INVALID_WRITE_IMMUTABLE_VALUE_KNOWN_SIGNATURE;
-  } else if (abstractValue.reason.has(ValueReason.ReactiveFunctionArgument)) {
-    return ErrorCode.INVALID_WRITE_IMMUTABLE_ARGS;
-  } else if (abstractValue.reason.has(ValueReason.State)) {
-    return ErrorCode.INVALID_WRITE_STATE;
-  } else if (abstractValue.reason.has(ValueReason.ReducerState)) {
-    return ErrorCode.INVALID_WRITE_REDUCER_STATE;
-  } else if (abstractValue.reason.has(ValueReason.Effect)) {
-    return ErrorCode.INVALID_WRITE_EFFECT_DEPENDENCY;
-  } else if (abstractValue.reason.has(ValueReason.HookCaptured)) {
-    return ErrorCode.INVALID_WRITE_HOOK_CAPTURED;
-  } else if (abstractValue.reason.has(ValueReason.HookReturn)) {
-    return ErrorCode.INVALID_WRITE_HOOK_RETURN;
-  } else {
-    return ErrorCode.INVALID_WRITE_GENERIC;
-  }
-}

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

@@ -1,218 +0,0 @@
-/**
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-import {
-  Effect,
-  HIRFunction,
-  Identifier,
-  InstructionId,
-  InstructionKind,
-  isArrayType,
-  isMapType,
-  isRefOrRefValue,
-  isSetType,
-  makeInstructionId,
-  Place,
-} from '../HIR/HIR';
-import {printPlace} from '../HIR/PrintHIR';
-import {
-  eachInstructionLValue,
-  eachInstructionOperand,
-  eachTerminalOperand,
-} from '../HIR/visitors';
-import {assertExhaustive} from '../Utils/utils';
-
-/*
- * For each usage of a value in the given function, determines if the usage
- * may be succeeded by a mutable usage of that same value and if so updates
- * the usage to be mutable.
- *
- * Stated differently, this inference ensures that inferred capabilities of
- * each reference are as follows:
- * - freeze: the value is frozen at this point
- * - readonly: the value is not modified at this point *or any subsequent
- *    point*
- * - mutable: the value is modified at this point *or some subsequent point*.
- *
- * Note that this refines the capabilities inferered by InferReferenceCapability,
- * which looks at individual references and not the lifetime of a value's mutability.
- *
- * == Algorithm
- *
- * TODO:
- * 1. Forward data-flow analysis to determine aliasing. Unlike InferReferenceCapability
- *     which only tracks aliasing of top-level variables (`y = x`), this analysis needs
- *     to know if a value is aliased anywhere (`y.x = x`). The forward data flow tracks
- *     all possible locations which may have aliased a value. The concrete result is
- *     a mapping of each Place to the set of possibly-mutable values it may alias.
- *
- * ```
- * const x = []; // {x: v0; v0: mutable []}
- * const y = {}; // {x: v0, y: v1; v0: mutable [], v1: mutable []}
- * y.x = x;      // {x: v0, y: v1; v0: mutable [v1], v1: mutable [v0]}
- * read(x);      // {x: v0, y: v1; v0: mutable [v1], v1: mutable [v0]}
- * mutate(y);    // can infer that y mutates v0 and v1
- * ```
- *
- * DONE:
- * 2. Forward data-flow analysis to compute mutability liveness. Walk forwards over
- *     the CFG and track which values are mutated in a successor.
- *
- * ```
- * mutate(y);    // mutable y => v0, v1 mutated
- * read(x);      // x maps to v0, v1, those are in the mutated-later set, so x is mutable here
- * ...
- * ```
- */
-
-function infer(place: Place, instrId: InstructionId): void {
-  if (!isRefOrRefValue(place.identifier)) {
-    place.identifier.mutableRange.end = makeInstructionId(instrId + 1);
-  }
-}
-
-function inferPlace(
-  place: Place,
-  instrId: InstructionId,
-  inferMutableRangeForStores: boolean,
-): void {
-  switch (place.effect) {
-    case Effect.Unknown: {
-      throw new Error(`Found an unknown place ${printPlace(place)}}!`);
-    }
-    case Effect.Capture:
-    case Effect.Read:
-    case Effect.Freeze:
-      return;
-    case Effect.Store:
-      if (inferMutableRangeForStores) {
-        infer(place, instrId);
-      }
-      return;
-    case Effect.ConditionallyMutateIterator: {
-      const identifier = place.identifier;
-      if (
-        !isArrayType(identifier) &&
-        !isSetType(identifier) &&
-        !isMapType(identifier)
-      ) {
-        infer(place, instrId);
-      }
-      return;
-    }
-    case Effect.ConditionallyMutate:
-    case Effect.Mutate: {
-      infer(place, instrId);
-      return;
-    }
-    default:
-      assertExhaustive(place.effect, `Unexpected ${printPlace(place)} effect`);
-  }
-}
-
-export function inferMutableLifetimes(
-  func: HIRFunction,
-  inferMutableRangeForStores: boolean,
-): void {
-  /*
-   * Context variables only appear to mutate where they are assigned, but we need
-   * to force their range to start at their declaration. Track the declaring instruction
-   * id so that the ranges can be extended if/when they are reassigned
-   */
-  const contextVariableDeclarationInstructions = new Map<
-    Identifier,
-    InstructionId
-  >();
-  for (const [_, block] of func.body.blocks) {
-    for (const phi of block.phis) {
-      const isPhiMutatedAfterCreation: boolean =
-        phi.place.identifier.mutableRange.end >
-        (block.instructions.at(0)?.id ?? block.terminal.id);
-      if (
-        inferMutableRangeForStores &&
-        isPhiMutatedAfterCreation &&
-        phi.place.identifier.mutableRange.start === 0
-      ) {
-        for (const [, operand] of phi.operands) {
-          if (phi.place.identifier.mutableRange.start === 0) {
-            phi.place.identifier.mutableRange.start =
-              operand.identifier.mutableRange.start;
-          } else {
-            phi.place.identifier.mutableRange.start = makeInstructionId(
-              Math.min(
-                phi.place.identifier.mutableRange.start,
-                operand.identifier.mutableRange.start,
-              ),
-            );
-          }
-        }
-      }
-    }
-
-    for (const instr of block.instructions) {
-      for (const operand of eachInstructionLValue(instr)) {
-        const lvalueId = operand.identifier;
-
-        /*
-         * lvalue start being mutable when they're initially assigned a
-         * value.
-         */
-        lvalueId.mutableRange.start = instr.id;
-
-        /*
-         * Let's be optimistic and assume this lvalue is not mutable by
-         * default.
-         */
-        lvalueId.mutableRange.end = makeInstructionId(instr.id + 1);
-      }
-      for (const operand of eachInstructionOperand(instr)) {
-        inferPlace(operand, instr.id, inferMutableRangeForStores);
-      }
-
-      if (
-        instr.value.kind === 'DeclareContext' ||
-        (instr.value.kind === 'StoreContext' &&
-          instr.value.lvalue.kind !== InstructionKind.Reassign &&
-          !contextVariableDeclarationInstructions.has(
-            instr.value.lvalue.place.identifier,
-          ))
-      ) {
-        /**
-         * Save declarations of context variables if they hasn't already been
-         * declared (due to hoisted declarations).
-         */
-        contextVariableDeclarationInstructions.set(
-          instr.value.lvalue.place.identifier,
-          instr.id,
-        );
-      } else if (instr.value.kind === 'StoreContext') {
-        /*
-         * Else this is a reassignment, extend the range from the declaration (if present).
-         * Note that declarations may not be present for context variables that are reassigned
-         * within a function expression before (or without) a read of the same variable
-         */
-        const declaration = contextVariableDeclarationInstructions.get(
-          instr.value.lvalue.place.identifier,
-        );
-        if (
-          declaration != null &&
-          !isRefOrRefValue(instr.value.lvalue.place.identifier)
-        ) {
-          const range = instr.value.lvalue.place.identifier.mutableRange;
-          if (range.start === 0) {
-            range.start = declaration;
-          } else {
-            range.start = makeInstructionId(Math.min(range.start, declaration));
-          }
-        }
-      }
-    }
-    for (const operand of eachTerminalOperand(block.terminal)) {
-      inferPlace(operand, block.terminal.id, inferMutableRangeForStores);
-    }
-  }
-}

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

@@ -1,102 +0,0 @@
-/**
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-import {HIRFunction, Identifier} from '../HIR/HIR';
-import {inferAliasForUncalledFunctions} from './InerAliasForUncalledFunctions';
-import {inferAliases} from './InferAlias';
-import {inferAliasForPhis} from './InferAliasForPhis';
-import {inferAliasForStores} from './InferAliasForStores';
-import {inferMutableLifetimes} from './InferMutableLifetimes';
-import {inferMutableRangesForAlias} from './InferMutableRangesForAlias';
-import {inferTryCatchAliases} from './InferTryCatchAliases';
-
-export function inferMutableRanges(ir: HIRFunction): void {
-  // Infer mutable ranges for non fields
-  inferMutableLifetimes(ir, false);
-
-  // Calculate aliases
-  const aliases = inferAliases(ir);
-  /*
-   * Calculate aliases for try/catch, where any value created
-   * in the try block could be aliased to the catch param
-   */
-  inferTryCatchAliases(ir, aliases);
-
-  /*
-   * Eagerly canonicalize so that if nothing changes we can bail out
-   * after a single iteration
-   */
-  let prevAliases: Map<Identifier, Identifier> = aliases.canonicalize();
-  while (true) {
-    // Infer mutable ranges for aliases that are not fields
-    inferMutableRangesForAlias(ir, aliases);
-
-    // Update aliasing information of fields
-    inferAliasForStores(ir, aliases);
-
-    // Update aliasing information of phis
-    inferAliasForPhis(ir, aliases);
-
-    const nextAliases = aliases.canonicalize();
-    if (areEqualMaps(prevAliases, nextAliases)) {
-      break;
-    }
-    prevAliases = nextAliases;
-  }
-
-  // Re-infer mutable ranges for all values
-  inferMutableLifetimes(ir, true);
-
-  /**
-   * The second inferMutableLifetimes() call updates mutable ranges
-   * of values to account for Store effects. Now we need to update
-   * all aliases of such values to extend their ranges as well. Note
-   * that the store only mutates the the directly aliased value and
-   * not any of its inner captured references. For example:
-   *
-   * ```
-   * let y;
-   * if (cond) {
-   *   y = [];
-   * } else {
-   *   y = [{}];
-   * }
-   * y.push(z);
-   * ```
-   *
-   * The Store effect from the `y.push` modifies the values that `y`
-   * directly aliases - the two arrays from the if/else branches -
-   * but does not modify values that `y` "contains" such as the
-   * object literal or `z`.
-   */
-  prevAliases = aliases.canonicalize();
-  while (true) {
-    inferMutableRangesForAlias(ir, aliases);
-    inferAliasForPhis(ir, aliases);
-    inferAliasForUncalledFunctions(ir, aliases);
-    const nextAliases = aliases.canonicalize();
-    if (areEqualMaps(prevAliases, nextAliases)) {
-      break;
-    }
-    prevAliases = nextAliases;
-  }
-}
-
-function areEqualMaps<T, U>(a: Map<T, U>, b: Map<T, U>): boolean {
-  if (a.size !== b.size) {
-    return false;
-  }
-  for (const [key, value] of a) {
-    if (!b.has(key)) {
-      return false;
-    }
-    if (b.get(key) !== value) {
-      return false;
-    }
-  }
-  return true;
-}

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

@@ -1,54 +0,0 @@
-/**
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-import {
-  HIRFunction,
-  Identifier,
-  InstructionId,
-  isRefOrRefValue,
-} from '../HIR/HIR';
-import DisjointSet from '../Utils/DisjointSet';
-
-export function inferMutableRangesForAlias(
-  _fn: HIRFunction,
-  aliases: DisjointSet<Identifier>,
-): void {
-  const aliasSets = aliases.buildSets();
-  for (const aliasSet of aliasSets) {
-    /*
-     * Update mutableRange.end only if the identifiers have actually been
-     * mutated.
-     */
-    const mutatingIdentifiers = [...aliasSet].filter(
-      id =>
-        id.mutableRange.end - id.mutableRange.start > 1 && !isRefOrRefValue(id),
-    );
-
-    if (mutatingIdentifiers.length > 0) {
-      // Find final instruction which mutates this alias set.
-      let lastMutatingInstructionId = 0;
-      for (const id of mutatingIdentifiers) {
-        if (id.mutableRange.end > lastMutatingInstructionId) {
-          lastMutatingInstructionId = id.mutableRange.end;
-        }
-      }
-
-      /*
-       * Update mutableRange.end for all aliases in this set ending before the
-       * last mutation.
-       */
-      for (const alias of aliasSet) {
-        if (
-          alias.mutableRange.end < lastMutatingInstructionId &&
-          !isRefOrRefValue(alias)
-        ) {
-          alias.mutableRange.end = lastMutatingInstructionId as InstructionId;
-        }
-      }
-    }
-  }
-}

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

@@ -9,6 +9,7 @@ import {
   CompilerDiagnostic,
   CompilerError,
   Effect,
+  ErrorSeverity,
   SourceLocation,
   ValueKind,
 } from '..';
@@ -18,6 +19,7 @@ import {
   DeclarationId,
   Environment,
   FunctionExpression,
+  GeneratedSource,
   HIRFunction,
   Hole,
   IdentifierId,
@@ -33,6 +35,7 @@ import {
   Phi,
   Place,
   SpreadPattern,
+  Type,
   ValueReason,
 } from '../HIR';
 import {
@@ -42,12 +45,6 @@ import {
   eachTerminalSuccessor,
 } from '../HIR/visitors';
 import {Ok, Result} from '../Utils/Result';
-import {
-  getArgumentEffect,
-  getFunctionCallSignature,
-  isKnownMutableEffect,
-  mergeValueKinds,
-} from './InferReferenceEffects';
 import {
   assertExhaustive,
   getOrInsertDefault,
@@ -64,11 +61,15 @@ import {
   printSourceLocation,
 } from '../HIR/PrintHIR';
 import {FunctionSignature} from '../HIR/ObjectShape';
-import {getWriteErrorReason} from './InferFunctionEffects';
 import prettyFormat from 'pretty-format';
 import {createTemporaryPlace} from '../HIR/HIRBuilder';
-import {AliasingEffect, AliasingSignature, hashEffect} from './AliasingEffects';
-import {ErrorCode, ErrorCodeDetails} from '../Utils/CompilerErrorCodes';
+import {
+  AliasingEffect,
+  AliasingSignature,
+  hashEffect,
+  MutationReason,
+} from './AliasingEffects';
+import {ErrorCategory} from '../CompilerError';
 
 const DEBUG = false;
 
@@ -442,27 +443,38 @@ function applySignature(
         const value = state.kind(effect.value);
         switch (value.kind) {
           case ValueKind.Frozen: {
-            const errorCode = getWriteErrorReason({
+            const reason = getWriteErrorReason({
               kind: value.kind,
               reason: value.reason,
-              context: new Set(),
             });
             const variable =
               effect.value.identifier.name !== null &&
               effect.value.identifier.name.kind === 'named'
                 ? `\`${effect.value.identifier.name.value}\``
                 : 'value';
+            const diagnostic = CompilerDiagnostic.create({
+              category: ErrorCategory.Immutability,
+              severity: ErrorSeverity.InvalidReact,
+              reason: 'This value cannot be modified',
+              description: `${reason}.`,
+            }).withDetail({
+              kind: 'error',
+              loc: effect.value.loc,
+              message: `${variable} cannot be modified`,
+            });
+            if (
+              effect.kind === 'Mutate' &&
+              effect.reason?.kind === 'AssignCurrentProperty'
+            ) {
+              diagnostic.withDetail({
+                kind: 'hint',
+                message: `Hint: If this value is a Ref (value returned by \`useRef()\`), rename the variable to end in "Ref".`,
+              });
+            }
             effects.push({
               kind: 'MutateFrozen',
               place: effect.value,
-              // TODO: remove ERROR_CODE.INVALID_WRITE and update test fixtures
-              error: CompilerDiagnostic.fromCode(ErrorCode.INVALID_WRITE, {
-                description: ErrorCodeDetails[errorCode].reason,
-              }).withDetail({
-                kind: 'error',
-                loc: effect.value.loc,
-                message: `${variable} cannot be modified`,
-              }),
+              error: diagnostic,
             });
           }
         }
@@ -1025,20 +1037,23 @@ function applyEffect(
           const hoistedAccess = context.hoistedContextDeclarations.get(
             effect.value.identifier.declarationId,
           );
-          const diagnostic = CompilerDiagnostic.fromCode(
-            ErrorCode.INVALID_ACCESS_BEFORE_INIT,
-          );
+          const diagnostic = CompilerDiagnostic.create({
+            category: ErrorCategory.Immutability,
+            severity: ErrorSeverity.InvalidReact,
+            reason: 'Cannot access variable before it is declared',
+            description: `${variable ?? 'This variable'} is accessed before it is declared, which prevents the earlier access from updating when this value changes over time.`,
+          });
           if (hoistedAccess != null && hoistedAccess.loc != effect.value.loc) {
             diagnostic.withDetail({
               kind: 'error',
               loc: hoistedAccess.loc,
-              message: `${variable ?? 'This variable'} is accessed before it is declared`,
+              message: `${variable ?? 'variable'} accessed before it is declared`,
             });
           }
           diagnostic.withDetail({
             kind: 'error',
             loc: effect.value.loc,
-            message: `${variable ?? 'This variable'} is declared here`,
+            message: `${variable ?? 'variable'} is declared here`,
           });
 
           applyEffect(
@@ -1053,16 +1068,34 @@ function applyEffect(
             effects,
           );
         } else {
-          const errorCode = getWriteErrorReason({
+          const reason = getWriteErrorReason({
             kind: value.kind,
             reason: value.reason,
-            context: new Set(),
           });
           const variable =
             effect.value.identifier.name !== null &&
             effect.value.identifier.name.kind === 'named'
               ? `\`${effect.value.identifier.name.value}\``
               : 'value';
+          const diagnostic = CompilerDiagnostic.create({
+            category: ErrorCategory.Immutability,
+            severity: ErrorSeverity.InvalidReact,
+            reason: 'This value cannot be modified',
+            description: `${reason}.`,
+          }).withDetail({
+            kind: 'error',
+            loc: effect.value.loc,
+            message: `${variable} cannot be modified`,
+          });
+          if (
+            effect.kind === 'Mutate' &&
+            effect.reason?.kind === 'AssignCurrentProperty'
+          ) {
+            diagnostic.withDetail({
+              kind: 'hint',
+              message: `Hint: If this value is a Ref (value returned by \`useRef()\`), rename the variable to end in "Ref".`,
+            });
+          }
           applyEffect(
             context,
             state,
@@ -1072,14 +1105,7 @@ function applyEffect(
                   ? 'MutateFrozen'
                   : 'MutateGlobal',
               place: effect.value,
-              // TODO: remove ERROR_CODE.INVALID_WRITE and update test fixtures
-              error: CompilerDiagnostic.fromCode(ErrorCode.INVALID_WRITE, {
-                description: ErrorCodeDetails[errorCode].reason,
-              }).withDetail({
-                kind: 'error',
-                loc: effect.value.loc,
-                message: `${variable} cannot be modified`,
-              }),
+              error: diagnostic,
             },
             initialized,
             effects,
@@ -1676,7 +1702,15 @@ function computeSignatureForInstruction(
     }
     case 'PropertyStore':
     case 'ComputedStore': {
-      effects.push({kind: 'Mutate', value: value.object});
+      const mutationReason: MutationReason | null =
+        value.kind === 'PropertyStore' && value.property === 'current'
+          ? {kind: 'AssignCurrentProperty'}
+          : null;
+      effects.push({
+        kind: 'Mutate',
+        value: value.object,
+        reason: mutationReason,
+      });
       effects.push({
         kind: 'Capture',
         from: value.value,
@@ -2002,12 +2036,16 @@ function computeSignatureForInstruction(
       effects.push({
         kind: 'MutateGlobal',
         place: value.value,
-        error: CompilerDiagnostic.fromCode(
-          ErrorCode.INVALID_WRITE_GLOBAL,
-        ).withDetail({
+        error: CompilerDiagnostic.create({
+          category: ErrorCategory.Globals,
+          severity: ErrorSeverity.InvalidReact,
+          reason:
+            'Cannot reassign variables declared outside of the component/hook',
+          description: `Variable ${variable} is declared outside of the component/hook. Reassigning this value during render is a form of side effect, which can cause unpredictable behavior depending on when the component happens to re-render. If this variable is used in rendering, use useState instead. Otherwise, consider updating it in an effect. (https://react.dev/reference/rules/components-and-hooks-must-be-pure#side-effects-must-run-outside-of-render)`,
+        }).withDetail({
           kind: 'error',
           loc: instr.loc,
-          message: `${variable} should not be reassigned`,
+          message: `${variable} cannot be reassigned`,
         }),
       });
       effects.push({kind: 'Assign', from: value.value, into: lvalue});
@@ -2098,16 +2136,20 @@ function computeEffectsForLegacySignature(
     effects.push({
       kind: 'Impure',
       place: receiver,
-      error: CompilerDiagnostic.fromCode(ErrorCode.IMPURE_FUNCTIONS).withDetail(
-        {
-          kind: 'error',
-          loc,
-          message:
-            signature.canonicalName != null
-              ? `\`${signature.canonicalName}\` is an impure function. `
-              : 'This is an impure function.',
-        },
-      ),
+      error: CompilerDiagnostic.create({
+        category: ErrorCategory.Purity,
+        severity: ErrorSeverity.InvalidReact,
+        reason: 'Cannot call impure function during render',
+        description:
+          (signature.canonicalName != null
+            ? `\`${signature.canonicalName}\` is an impure function. `
+            : '') +
+          'Calling an impure function can produce unstable results that update unpredictably when the component happens to re-render. (https://react.dev/reference/rules/components-and-hooks-must-be-pure#components-and-hooks-must-be-idempotent)',
+      }).withDetail({
+        kind: 'error',
+        loc,
+        message: 'Cannot call impure function',
+      }),
     });
   }
   const stores: Array<Place> = [];
@@ -2524,3 +2566,196 @@ export type AbstractValue = {
   kind: ValueKind;
   reason: ReadonlySet<ValueReason>;
 };
+
+export function getWriteErrorReason(abstractValue: AbstractValue): string {
+  if (abstractValue.reason.has(ValueReason.Global)) {
+    return 'Modifying a variable defined outside a component or hook is not allowed. Consider using an effect';
+  } else if (abstractValue.reason.has(ValueReason.JsxCaptured)) {
+    return 'Modifying a value used previously in JSX is not allowed. Consider moving the modification before the JSX';
+  } else if (abstractValue.reason.has(ValueReason.Context)) {
+    return `Modifying a value returned from 'useContext()' is not allowed.`;
+  } else if (abstractValue.reason.has(ValueReason.KnownReturnSignature)) {
+    return 'Modifying a value returned from a function whose return value should not be mutated';
+  } else if (abstractValue.reason.has(ValueReason.ReactiveFunctionArgument)) {
+    return 'Modifying component props or hook arguments is not allowed. Consider using a local variable instead';
+  } else if (abstractValue.reason.has(ValueReason.State)) {
+    return "Modifying a value returned from 'useState()', which should not be modified directly. Use the setter function to update instead";
+  } else if (abstractValue.reason.has(ValueReason.ReducerState)) {
+    return "Modifying a value returned from 'useReducer()', which should not be modified directly. Use the dispatch function to update instead";
+  } else if (abstractValue.reason.has(ValueReason.Effect)) {
+    return 'Modifying a value used previously in an effect function or as an effect dependency is not allowed. Consider moving the modification before calling useEffect()';
+  } else if (abstractValue.reason.has(ValueReason.HookCaptured)) {
+    return 'Modifying a value previously passed as an argument to a hook is not allowed. Consider moving the modification before calling the hook';
+  } else if (abstractValue.reason.has(ValueReason.HookReturn)) {
+    return 'Modifying a value returned from a hook is not allowed. Consider moving the modification into the hook where the value is constructed';
+  } else {
+    return 'This modifies a variable that React considers immutable';
+  }
+}
+
+function getArgumentEffect(
+  signatureEffect: Effect | null,
+  arg: Place | SpreadPattern,
+): Effect {
+  if (signatureEffect != null) {
+    if (arg.kind === 'Identifier') {
+      return signatureEffect;
+    } else if (
+      signatureEffect === Effect.Mutate ||
+      signatureEffect === Effect.ConditionallyMutate
+    ) {
+      return signatureEffect;
+    } else {
+      // see call-spread-argument-mutable-iterator test fixture
+      if (signatureEffect === Effect.Freeze) {
+        CompilerError.throwTodo({
+          reason: 'Support spread syntax for hook arguments',
+          loc: arg.place.loc,
+        });
+      }
+      // effects[i] is Effect.Capture | Effect.Read | Effect.Store
+      return Effect.ConditionallyMutateIterator;
+    }
+  } else {
+    return Effect.ConditionallyMutate;
+  }
+}
+
+export function getFunctionCallSignature(
+  env: Environment,
+  type: Type,
+): FunctionSignature | null {
+  if (type.kind !== 'Function') {
+    return null;
+  }
+  return env.getFunctionSignature(type);
+}
+
+export function isKnownMutableEffect(effect: Effect): boolean {
+  switch (effect) {
+    case Effect.Store:
+    case Effect.ConditionallyMutate:
+    case Effect.ConditionallyMutateIterator:
+    case Effect.Mutate: {
+      return true;
+    }
+
+    case Effect.Unknown: {
+      CompilerError.invariant(false, {
+        reason: 'Unexpected unknown effect',
+        description: null,
+        loc: GeneratedSource,
+        suggestions: null,
+      });
+    }
+    case Effect.Read:
+    case Effect.Capture:
+    case Effect.Freeze: {
+      return false;
+    }
+    default: {
+      assertExhaustive(effect, `Unexpected effect \`${effect}\``);
+    }
+  }
+}
+
+/**
+ * Joins two values using the following rules:
+ * == Effect Transitions ==
+ *
+ * Freezing an immutable value has not effect:
+ *                ┌───────────────┐
+ *                │               │
+ *                ▼               │ Freeze
+ * ┌──────────────────────────┐  │
+ * │        Immutable         │──┘
+ * └──────────────────────────┘
+ *
+ * Freezing a mutable or maybe-frozen value makes it frozen. Freezing a frozen
+ * value has no effect:
+ *                                                     ┌───────────────┐
+ * ┌─────────────────────────┐     Freeze             │               │
+ * │       MaybeFrozen       │────┐                   ▼               │ Freeze
+ * └─────────────────────────┘    │     ┌──────────────────────────┐  │
+ *                                 ├────▶│          Frozen          │──┘
+ *                                 │     └──────────────────────────┘
+ * ┌─────────────────────────┐    │
+ * │         Mutable         │────┘
+ * └─────────────────────────┘
+ *
+ * == Join Lattice ==
+ * - immutable | mutable => mutable
+ *     The justification is that immutable and mutable values are different types,
+ *     and functions can introspect them to tell the difference (if the argument
+ *     is null return early, else if its an object mutate it).
+ * - frozen | mutable => maybe-frozen
+ *     Frozen values are indistinguishable from mutable values at runtime, so callers
+ *     cannot dynamically avoid mutation of "frozen" values. If a value could be
+ *     frozen we have to distinguish it from a mutable value. But it also isn't known
+ *     frozen yet, so we distinguish as maybe-frozen.
+ * - immutable | frozen => frozen
+ *     This is subtle and falls out of the above rules. If a value could be any of
+ *     immutable, mutable, or frozen, then at runtime it could either be a primitive
+ *     or a reference type, and callers can't distinguish frozen or not for reference
+ *     types. To ensure that any sequence of joins btw those three states yields the
+ *     correct maybe-frozen, these two have to produce a frozen value.
+ * - <any> | maybe-frozen => maybe-frozen
+ * - immutable | context => context
+ * - mutable | context => context
+ * - frozen | context => maybe-frozen
+ *
+ * ┌──────────────────────────┐
+ * │        Immutable         │───┐
+ * └──────────────────────────┘   │
+ *                                 │    ┌─────────────────────────┐
+ *                                 ├───▶│         Frozen          │──┐
+ * ┌──────────────────────────┐   │    └─────────────────────────┘  │
+ * │          Frozen          │───┤                                 │  ┌─────────────────────────┐
+ * └──────────────────────────┘   │                                 ├─▶│       MaybeFrozen       │
+ *                                 │    ┌─────────────────────────┐  │  └─────────────────────────┘
+ *                                 ├───▶│       MaybeFrozen       │──┘
+ * ┌──────────────────────────┐   │    └─────────────────────────┘
+ * │         Mutable          │───┘
+ * └──────────────────────────┘
+ */
+function mergeValueKinds(a: ValueKind, b: ValueKind): ValueKind {
+  if (a === b) {
+    return a;
+  } else if (a === ValueKind.MaybeFrozen || b === ValueKind.MaybeFrozen) {
+    return ValueKind.MaybeFrozen;
+    // after this a and b differ and neither are MaybeFrozen
+  } else if (a === ValueKind.Mutable || b === ValueKind.Mutable) {
+    if (a === ValueKind.Frozen || b === ValueKind.Frozen) {
+      // frozen | mutable
+      return ValueKind.MaybeFrozen;
+    } else if (a === ValueKind.Context || b === ValueKind.Context) {
+      // context | mutable
+      return ValueKind.Context;
+    } else {
+      // mutable | immutable
+      return ValueKind.Mutable;
+    }
+  } else if (a === ValueKind.Context || b === ValueKind.Context) {
+    if (a === ValueKind.Frozen || b === ValueKind.Frozen) {
+      // frozen | context
+      return ValueKind.MaybeFrozen;
+    } else {
+      // context | immutable
+      return ValueKind.Context;
+    }
+  } else if (a === ValueKind.Frozen || b === ValueKind.Frozen) {
+    return ValueKind.Frozen;
+  } else if (a === ValueKind.Global || b === ValueKind.Global) {
+    return ValueKind.Global;
+  } else {
+    CompilerError.invariant(
+      a === ValueKind.Primitive && b == ValueKind.Primitive,
+      {
+        reason: `Unexpected value kind in mergeValues()`,
+        description: `Found kinds ${a} and ${b}`,
+        loc: GeneratedSource,
+      },
+    );
+    return ValueKind.Primitive;
+  }
+}

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

@@ -1,49 +0,0 @@
-/**
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-import {BlockId, HIRFunction, Identifier} from '../HIR';
-import DisjointSet from '../Utils/DisjointSet';
-
-/*
- * Any values created within a try/catch block could be aliased to the try handler.
- * Our lowering ensures that every instruction within a try block will be lowered into a
- * basic block ending in a maybe-throw terminal that points to its catch block, so we can
- * iterate such blocks and alias their instruction lvalues to the handler's param (if present).
- */
-export function inferTryCatchAliases(
-  fn: HIRFunction,
-  aliases: DisjointSet<Identifier>,
-): void {
-  const handlerParams: Map<BlockId, Identifier> = new Map();
-  for (const [_, block] of fn.body.blocks) {
-    if (
-      block.terminal.kind === 'try' &&
-      block.terminal.handlerBinding !== null
-    ) {
-      handlerParams.set(
-        block.terminal.handler,
-        block.terminal.handlerBinding.identifier,
-      );
-    } else if (block.terminal.kind === 'maybe-throw') {
-      const handlerParam = handlerParams.get(block.terminal.handler);
-      if (handlerParam === undefined) {
-        /*
-         * There's no catch clause param, nothing to alias to so
-         * skip this block
-         */
-        continue;
-      }
-      /*
-       * Otherwise alias all values created in this block to the
-       * catch clause param
-       */
-      for (const instr of block.instructions) {
-        aliases.union([handlerParam, instr.lvalue.identifier]);
-      }
-    }
-  }
-}

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

@@ -7,8 +7,6 @@
 
 export {default as analyseFunctions} from './AnalyseFunctions';
 export {dropManualMemoization} from './DropManualMemoization';
-export {inferMutableRanges} from './InferMutableRanges';
 export {inferReactivePlaces} from './InferReactivePlaces';
-export {default as inferReferenceEffects} from './InferReferenceEffects';
 export {inlineImmediatelyInvokedFunctionExpressions} from './InlineImmediatelyInvokedFunctionExpressions';
 export {inferEffectDependencies} from './InferEffectDependencies';

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

@@ -42,6 +42,7 @@ import {
   mapInstructionValueOperands,
   mapTerminalOperands,
 } from '../HIR/visitors';
+import {ErrorCategory} from '../CompilerError';
 
 type InlinedJsxDeclarationMap = Map<
   DeclarationId,
@@ -83,6 +84,7 @@ export function inlineJsxTransform(
           kind: 'CompileDiagnostic',
           fnLoc: null,
           detail: {
+            category: ErrorCategory.Todo,
             reason: 'JSX Inlining is not supported on value blocks',
             loc: instr.loc,
           },

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

@@ -255,7 +255,6 @@ function emitSelectorFn(env: Environment, keys: Array<string>): Instruction {
     returnTypeAnnotation: null,
     returns: createTemporaryPlace(env, GeneratedSource),
     context: [],
-    effects: null,
     body: {
       entry: block.id,
       blocks: new Map([[block.id, block]]),
@@ -263,6 +262,7 @@ function emitSelectorFn(env: Environment, keys: Array<string>): Instruction {
     generator: false,
     async: false,
     directives: [],
+    aliasingEffects: [],
   };
 
   reversePostorderBlocks(fn.body);

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

@@ -370,7 +370,6 @@ function emitOutlinedFn(
     returnTypeAnnotation: null,
     returns: createTemporaryPlace(env, GeneratedSource),
     context: [],
-    effects: null,
     body: {
       entry: block.id,
       blocks: new Map([[block.id, block]]),
@@ -378,6 +377,7 @@ function emitOutlinedFn(
     generator: false,
     async: false,
     directives: [],
+    aliasingEffects: [],
   };
   return fn;
 }

compiler/packages/babel-plugin-react-compiler/src/ReactiveScopes/CodegenReactiveFunction.ts

@@ -13,7 +13,7 @@ import {
   pruneUnusedLabels,
   renameVariables,
 } from '.';
-import {CompilerError, ErrorSeverity} from '../CompilerError';
+import {CompilerError, ErrorCategory, ErrorSeverity} from '../CompilerError';
 import {Environment, ExternalFunction} from '../HIR';
 import {
   ArrayPattern,
@@ -2185,6 +2185,7 @@ function codegenInstructionValue(
                 (declarator.id as t.Identifier).name
               }'`,
               severity: ErrorSeverity.Todo,
+              category: ErrorCategory.Todo,
               loc: declarator.loc ?? null,
               suggestions: null,
             });
@@ -2193,6 +2194,7 @@ function codegenInstructionValue(
             cx.errors.push({
               reason: `(CodegenReactiveFunction::codegenInstructionValue) Handle conversion of ${stmt.type} to expression`,
               severity: ErrorSeverity.Todo,
+              category: ErrorCategory.Todo,
               loc: stmt.loc ?? null,
               suggestions: null,
             });

compiler/packages/babel-plugin-react-compiler/src/ReactiveScopes/PruneNonEscapingScopes.ts

@@ -24,7 +24,6 @@ import {
   getHookKind,
   isMutableEffect,
 } from '../HIR';
-import {getFunctionCallSignature} from '../Inference/InferReferenceEffects';
 import {assertExhaustive, getOrInsertDefault} from '../Utils/utils';
 import {getPlaceScope, ReactiveScope} from '../HIR/HIR';
 import {
@@ -35,6 +34,7 @@ import {
   visitReactiveFunction,
 } from './visitors';
 import {printPlace} from '../HIR/PrintHIR';
+import {getFunctionCallSignature} from '../Inference/InferMutationAliasingEffects';
 
 /*
  * This pass prunes reactive scopes that are not necessary to bound downstream computation.

compiler/packages/babel-plugin-react-compiler/src/Transform/TransformFire.ts

@@ -42,7 +42,7 @@ import {
 import {eachInstructionOperand} from '../HIR/visitors';
 import {printSourceLocationLine} from '../HIR/PrintHIR';
 import {USE_FIRE_FUNCTION_NAME} from '../HIR/Environment';
-import {ErrorCode} from '../Utils/CompilerErrorCodes';
+import {ErrorCategory} from '../CompilerError';
 
 /*
  * TODO(jmbrown):
@@ -51,6 +51,8 @@ import {ErrorCode} from '../Utils/CompilerErrorCodes';
  *   - React.useEffect calls
  */
 
+const CANNOT_COMPILE_FIRE = 'Cannot compile `fire`';
+
 export function transformFire(fn: HIRFunction): void {
   const context = new Context(fn.env);
   replaceFireFunctions(fn, context);
@@ -132,6 +134,7 @@ function replaceFireFunctions(fn: HIRFunction, context: Context): void {
                   loc: value.loc,
                   description: null,
                   severity: ErrorSeverity.Invariant,
+                  category: ErrorCategory.Invariant,
                   reason: '[InsertFire] No LoadGlobal found for useEffect call',
                   suggestions: null,
                 });
@@ -177,7 +180,10 @@ function replaceFireFunctions(fn: HIRFunction, context: Context): void {
                 loc: value.args[1].loc,
                 description:
                   'You must use an array literal for an effect dependency array when that effect uses `fire()`',
-                errorCode: ErrorCode.CANNOT_COMPILE_FIRE,
+                severity: ErrorSeverity.Invariant,
+                category: ErrorCategory.Fire,
+                reason: CANNOT_COMPILE_FIRE,
+                suggestions: null,
               });
             }
           } else if (value.args.length > 1 && value.args[1].kind === 'Spread') {
@@ -185,7 +191,10 @@ function replaceFireFunctions(fn: HIRFunction, context: Context): void {
               loc: value.args[1].place.loc,
               description:
                 'You must use an array literal for an effect dependency array when that effect uses `fire()`',
-              errorCode: ErrorCode.CANNOT_COMPILE_FIRE,
+              severity: ErrorSeverity.Invariant,
+              category: ErrorCategory.Fire,
+              reason: CANNOT_COMPILE_FIRE,
+              suggestions: null,
             });
           }
         }
@@ -218,6 +227,7 @@ function replaceFireFunctions(fn: HIRFunction, context: Context): void {
                 loc: value.loc,
                 description: null,
                 severity: ErrorSeverity.Invariant,
+                category: ErrorCategory.Invariant,
                 reason:
                   '[InsertFire] No loadLocal found for fire call argument',
                 suggestions: null,
@@ -238,9 +248,12 @@ function replaceFireFunctions(fn: HIRFunction, context: Context): void {
           } else {
             context.pushError({
               loc: value.loc,
-              errorCode: ErrorCode.CANNOT_COMPILE_FIRE,
               description:
                 '`fire()` can only receive a function call such as `fire(fn(a,b)). Method calls and other expressions are not allowed',
+              severity: ErrorSeverity.InvalidReact,
+              category: ErrorCategory.Fire,
+              reason: CANNOT_COMPILE_FIRE,
+              suggestions: null,
             });
           }
         } else {
@@ -255,8 +268,11 @@ function replaceFireFunctions(fn: HIRFunction, context: Context): void {
           }
           context.pushError({
             loc: value.loc,
-            errorCode: ErrorCode.CANNOT_COMPILE_FIRE,
             description,
+            severity: ErrorSeverity.InvalidReact,
+            category: ErrorCategory.Fire,
+            reason: CANNOT_COMPILE_FIRE,
+            suggestions: null,
           });
         }
       } else if (value.kind === 'CallExpression') {
@@ -385,7 +401,10 @@ function ensureNoRemainingCalleeCaptures(
         description: `All uses of ${calleeName} must be either used with a fire() call in \
 this effect or not used with a fire() call at all. ${calleeName} was used with fire() on line \
 ${printSourceLocationLine(calleeInfo.fireLoc)} in this effect`,
-        errorCode: ErrorCode.CANNOT_COMPILE_FIRE,
+        severity: ErrorSeverity.InvalidReact,
+        category: ErrorCategory.Fire,
+        reason: CANNOT_COMPILE_FIRE,
+        suggestions: null,
       });
     }
   }
@@ -400,7 +419,10 @@ function ensureNoMoreFireUses(fn: HIRFunction, context: Context): void {
       context.pushError({
         loc: place.identifier.loc,
         description: 'Cannot use `fire` outside of a useEffect function',
-        errorCode: ErrorCode.CANNOT_COMPILE_FIRE,
+        category: ErrorCategory.Fire,
+        severity: ErrorSeverity.Invariant,
+        reason: CANNOT_COMPILE_FIRE,
+        suggestions: null,
       });
     }
   }

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

@@ -1,624 +0,0 @@
-import {ErrorSeverity} from './CompilerErrorSeverity';
-
-export enum LinterCategory {
-  RULES_OF_HOOKS = 'rules-of-hooks',
-  IMPURE_FUNCTIONS = 'impure-functions',
-  JSX_IN_TRY = 'jsx-in-try',
-  NO_REF_ACCESS_IN_RENDER = 'no-ref-access-in-render',
-  VALIDATE_MANUAL_MEMO = 'validate-manual-memo',
-  DYNAMIC_MANUAL_MEMO = 'dynamic-manual-memo',
-
-  EXHAUSTIVE_DEPS = 'exhaustive-deps',
-  MEMOIZED_DEPENDENCIES = 'memoized-dependencies', // not real!
-  INVALID_WRITE = 'invalid-write',
-  CAPITALIZED_CALLS = 'capitalized-calls',
-  STATIC_COMPONENTS = 'static-components',
-  NO_SET_STATE_IN_RENDER = 'no-set-state-in-render',
-  NO_SET_STATE_IN_EFFECTS = 'no-set-state-in-effects',
-  UNNECESSARY_EFFECTS = 'unnecessary-effects',
-
-  UNSUPPORTED_SYNTAX = 'unsupported-syntax',
-
-  TODO_SYNTAX = 'todo-syntax',
-
-  COMPILER_CONFIG = 'compiler-config',
-}
-
-export enum ErrorCode {
-  HOOK_CALL_STATIC,
-  HOOK_INVALID_REFERENCE,
-  HOOK_CALL_REACTIVE,
-  HOOK_CALL_NOT_TOP_LEVEL,
-  IMPURE_FUNCTIONS,
-  JSX_IN_TRY,
-  NO_REF_ACCESS_IN_RENDER,
-  WRITE_AFTER_RENDER,
-  REASSIGN_AFTER_RENDER,
-  REASSIGN_IN_ASYNC,
-  INVALID_WRITE,
-  CAPITALIZED_CALLS,
-  STATIC_COMPONENTS,
-  INVALID_USE_MEMO_CALLBACK_RETURN,
-  INVALID_USE_MEMO_CALLBACK_PARAMETERS,
-  INVALID_USE_MEMO_CALLBACK_ASYNC,
-  INVALID_USE_MEMO_NO_ARG0,
-  INVALID_USE_CALLBACK_NO_ARG0,
-  DYNAMIC_MANUAL_MEMO_CALLBACK,
-  DYNAMIC_USE_MEMO_SPREAD_ARGUMENT,
-  DYNAMIC_USE_CALLBACK_SPREAD_ARGUMENT,
-  DYNAMIC_MANUAL_MEMO_DEPENDENCY_LIST,
-  COMPLEX_MANUAL_MEMO_DEPENDENCY_LIST_ENTRY,
-
-  INVALID_SET_STATE_IN_RENDER,
-  INVALID_SET_STATE_IN_MEMO,
-  INVALID_SET_STATE_IN_EFFECTS,
-
-  NO_DERIVED_COMPUTATIONS_IN_EFFECTS,
-
-  DYNAMIC_GATING_IS_NOT_IDENTIFIER,
-  DYNAMIC_GATING_MULTIPLE_DIRECTIVES,
-  FILENAME_NOT_SET,
-
-  INVALID_WRITE_GLOBAL,
-  INVALID_WRITE_FROZEN_VALUE_JSX,
-  INVALID_WRITE_IMMUTABLE_VALUE_USE_CONTEXT,
-  INVALID_WRITE_IMMUTABLE_VALUE_KNOWN_SIGNATURE,
-  INVALID_WRITE_IMMUTABLE_ARGS,
-  INVALID_WRITE_STATE,
-  INVALID_WRITE_REDUCER_STATE,
-  INVALID_WRITE_EFFECT_DEPENDENCY,
-  INVALID_WRITE_HOOK_CAPTURED,
-  INVALID_WRITE_HOOK_RETURN,
-  INVALID_ACCESS_BEFORE_INIT,
-  INVALID_WRITE_GENERIC,
-
-  MEMOIZED_EFFECT_DEPENDENCIES,
-
-  INVALID_SYNTAX_MULTIPLE_DEFAULTS,
-  INVALID_SYNTAX_REASSIGNED_CONST,
-  INVALID_SYNTAX_BAD_VARIABLE_DECL,
-  UNSUPPORTED_WITH,
-  UNSUPPORTED_INNER_CLASS,
-  INVALID_IMPORT_EXPORT,
-  INVALID_TS_NAMESPACE,
-  UNSUPPORTED_NEW_EXPRESSION,
-  UNSUPPORTED_EMPTY_SEQUENCE_EXPRESSION,
-  INVALID_QUASI_LENGTHS,
-  INVALID_SYNTAX_DELETE_EXPRESSION,
-  UNSUPPORTED_THROW_EXPRESSION,
-  INVALID_JSX_NAMESPACED_NAME,
-  UNSUPPORTED_EVAL,
-  INVALID_SYNTAX_RESERVED_VARIABLE_NAME,
-  INVALID_JAVASCRIPT_AST,
-  BAILOUT_ESLINT_SUPPRESSION,
-  BAILOUT_FLOW_SUPPRESSION,
-  MANUAL_MEMO_MUTATED_LATER,
-  MANUAL_MEMO_REMOVED,
-  MANUAL_MEMO_DEPENDENCIES_CONFLICT,
-
-  CANNOT_COMPILE_FIRE,
-  DID_NOT_INFER_DEPS,
-
-  /** Todo syntax */
-  TODO_CONFLICTING_FBT_IDENTIFIER,
-  TODO_DUPLICATE_FBT_TAGS,
-  UNKNOWN_FUNCTION_PARAMETERS,
-}
-
-type ErrorCodeType = {
-  code: ErrorCode;
-  description?: string;
-  severity: ErrorSeverity;
-  reason: string;
-  linterCategory: LinterCategory | null;
-};
-
-export const ErrorCodeDetails: Record<ErrorCode, ErrorCodeType> = {
-  [ErrorCode.HOOK_CALL_STATIC]: {
-    code: ErrorCode.HOOK_CALL_STATIC,
-    severity: ErrorSeverity.InvalidReact,
-    reason:
-      'Hooks must always be called in a consistent order, and may not be called conditionally. See the Rules of Hooks (https://react.dev/warnings/invalid-hook-call-warning)',
-    linterCategory: LinterCategory.RULES_OF_HOOKS,
-  },
-  [ErrorCode.HOOK_INVALID_REFERENCE]: {
-    code: ErrorCode.HOOK_INVALID_REFERENCE,
-    severity: ErrorSeverity.InvalidReact,
-    reason:
-      'Hooks may not be referenced as normal values, they must be called. See https://react.dev/reference/rules/react-calls-components-and-hooks#never-pass-around-hooks-as-regular-values',
-    linterCategory: LinterCategory.RULES_OF_HOOKS,
-  },
-  [ErrorCode.HOOK_CALL_REACTIVE]: {
-    code: ErrorCode.HOOK_CALL_REACTIVE,
-    severity: ErrorSeverity.InvalidReact,
-    reason:
-      'Hooks must be the same function on every render, but this value may change over time to a different function. See https://react.dev/reference/rules/react-calls-components-and-hooks#dont-dynamically-use-hooks',
-    linterCategory: LinterCategory.RULES_OF_HOOKS,
-  },
-  [ErrorCode.HOOK_CALL_NOT_TOP_LEVEL]: {
-    code: ErrorCode.HOOK_CALL_NOT_TOP_LEVEL,
-    severity: ErrorSeverity.InvalidReact,
-    reason:
-      'Hooks must be called at the top level in the body of a function component or custom hook, and may not be called within function expressions. See the Rules of Hooks (https://react.dev/warnings/invalid-hook-call-warning)',
-    linterCategory: LinterCategory.RULES_OF_HOOKS,
-  },
-  [ErrorCode.IMPURE_FUNCTIONS]: {
-    code: ErrorCode.IMPURE_FUNCTIONS,
-    severity: ErrorSeverity.InvalidReact,
-    reason: 'Cannot call impure functions during render',
-    description:
-      'Calling an impure function can produce unstable results that change unpredictably when the component happens to re-render. (https://react.dev/reference/rules/components-and-hooks-must-be-pure#components-and-hooks-must-be-idempotent)',
-    linterCategory: LinterCategory.IMPURE_FUNCTIONS,
-  },
-  [ErrorCode.JSX_IN_TRY]: {
-    code: ErrorCode.JSX_IN_TRY,
-    severity: ErrorSeverity.InvalidReact,
-    reason: 'Avoid constructing JSX within try/catch',
-    description: `React does not immediately render components when JSX is rendered, so any errors from this component will not be caught by the try/catch. To catch errors in rendering a given component, wrap that component in an error boundary. (https://react.dev/reference/react/Component#catching-rendering-errors-with-an-error-boundary)`,
-    linterCategory: LinterCategory.JSX_IN_TRY,
-  },
-  [ErrorCode.NO_REF_ACCESS_IN_RENDER]: {
-    code: ErrorCode.NO_REF_ACCESS_IN_RENDER,
-    severity: ErrorSeverity.InvalidReact,
-    reason: 'Cannot access refs during render',
-    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)',
-    linterCategory: LinterCategory.NO_REF_ACCESS_IN_RENDER,
-  },
-  [ErrorCode.INVALID_SET_STATE_IN_EFFECTS]: {
-    code: ErrorCode.INVALID_SET_STATE_IN_EFFECTS,
-    severity: ErrorSeverity.InvalidReact,
-    reason:
-      '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\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)',
-    linterCategory: LinterCategory.NO_SET_STATE_IN_EFFECTS,
-  },
-  [ErrorCode.WRITE_AFTER_RENDER]: {
-    code: ErrorCode.WRITE_AFTER_RENDER,
-    severity: ErrorSeverity.InvalidReact,
-    reason: 'Cannot modify local variables after render completes',
-    description: `This argument is a function which may reassign or mutate a variable after render, which can cause inconsistent behavior on subsequent renders. Consider using state instead`,
-    linterCategory: LinterCategory.INVALID_WRITE,
-  },
-  [ErrorCode.REASSIGN_AFTER_RENDER]: {
-    code: ErrorCode.REASSIGN_AFTER_RENDER,
-    severity: ErrorSeverity.InvalidReact,
-    reason: 'Cannot reassign local variables after render completes',
-    description: `Reassigning local variables after render has completed can cause inconsistent behavior on subsequent renders. Consider using state instead`,
-    linterCategory: LinterCategory.INVALID_WRITE,
-  },
-  [ErrorCode.REASSIGN_IN_ASYNC]: {
-    code: ErrorCode.REASSIGN_IN_ASYNC,
-    severity: ErrorSeverity.InvalidReact,
-    reason: 'Cannot reassign variable in async function',
-    description:
-      'Reassigning a variable in an async function can cause inconsistent behavior on subsequent renders. Consider using state instead',
-    linterCategory: LinterCategory.INVALID_WRITE,
-  },
-  [ErrorCode.INVALID_WRITE]: {
-    code: ErrorCode.INVALID_WRITE,
-    severity: ErrorSeverity.InvalidReact,
-    reason: 'This value cannot be modified',
-    linterCategory: LinterCategory.INVALID_WRITE,
-  },
-  [ErrorCode.CAPITALIZED_CALLS]: {
-    code: ErrorCode.CAPITALIZED_CALLS,
-    severity: ErrorSeverity.InvalidReact,
-    reason:
-      'Capitalized functions are reserved for components, which must be invoked with JSX. If this is a component, render it with JSX. Otherwise, ensure that it has no hook calls and rename it to begin with a lowercase letter. Alternatively, if you know for a fact that this function is not a component, you can allowlist it via the compiler config',
-    linterCategory: LinterCategory.CAPITALIZED_CALLS,
-  },
-  [ErrorCode.STATIC_COMPONENTS]: {
-    code: ErrorCode.STATIC_COMPONENTS,
-    severity: ErrorSeverity.InvalidReact,
-    reason: 'Cannot create components during render',
-    linterCategory: LinterCategory.STATIC_COMPONENTS,
-  },
-  [ErrorCode.INVALID_USE_MEMO_NO_ARG0]: {
-    code: ErrorCode.INVALID_USE_MEMO_NO_ARG0,
-    severity: ErrorSeverity.InvalidReact,
-    reason: `Expected a callback function to be passed to useMemo`,
-    linterCategory: LinterCategory.VALIDATE_MANUAL_MEMO,
-  },
-  [ErrorCode.INVALID_USE_CALLBACK_NO_ARG0]: {
-    code: ErrorCode.INVALID_USE_CALLBACK_NO_ARG0,
-    severity: ErrorSeverity.InvalidReact,
-    reason: `Expected a callback function to be passed to useCallback`,
-    linterCategory: LinterCategory.VALIDATE_MANUAL_MEMO,
-  },
-  [ErrorCode.DYNAMIC_USE_MEMO_SPREAD_ARGUMENT]: {
-    code: ErrorCode.DYNAMIC_USE_MEMO_SPREAD_ARGUMENT,
-    severity: ErrorSeverity.InvalidReact,
-    reason: 'Unexpected spread argument to useMemo',
-    linterCategory: LinterCategory.DYNAMIC_MANUAL_MEMO,
-  },
-
-  [ErrorCode.DYNAMIC_USE_CALLBACK_SPREAD_ARGUMENT]: {
-    code: ErrorCode.DYNAMIC_USE_CALLBACK_SPREAD_ARGUMENT,
-    severity: ErrorSeverity.InvalidReact,
-    reason: 'Unexpected spread argument to useCallback',
-    linterCategory: LinterCategory.DYNAMIC_MANUAL_MEMO,
-  },
-  [ErrorCode.INVALID_USE_MEMO_CALLBACK_PARAMETERS]: {
-    code: ErrorCode.INVALID_USE_MEMO_CALLBACK_PARAMETERS,
-    severity: ErrorSeverity.InvalidReact,
-    reason: 'useMemo() callbacks may not accept parameters',
-    description:
-      'useMemo() callbacks are called by React to cache calculations across re-renders. They cannot accept parameters. Instead, directly reference the props, state, or local variables needed for the computation',
-    linterCategory: LinterCategory.VALIDATE_MANUAL_MEMO,
-  },
-  [ErrorCode.INVALID_USE_MEMO_CALLBACK_ASYNC]: {
-    code: ErrorCode.INVALID_USE_MEMO_CALLBACK_ASYNC,
-    severity: ErrorSeverity.InvalidReact,
-    reason: 'useMemo() callbacks may not be async or generator functions',
-    description:
-      'useMemo() callbacks are called once and must synchronously return a value',
-    linterCategory: LinterCategory.VALIDATE_MANUAL_MEMO,
-  },
-  [ErrorCode.INVALID_USE_MEMO_CALLBACK_RETURN]: {
-    code: ErrorCode.INVALID_USE_MEMO_CALLBACK_RETURN,
-    severity: ErrorSeverity.InvalidReact,
-    reason: 'useMemo() callbacks must return a value',
-    linterCategory: LinterCategory.VALIDATE_MANUAL_MEMO,
-  },
-  [ErrorCode.DYNAMIC_MANUAL_MEMO_CALLBACK]: {
-    code: ErrorCode.DYNAMIC_MANUAL_MEMO_CALLBACK,
-    severity: ErrorSeverity.InvalidReact,
-    reason: `Expected the first argument to be an inline function expression`,
-    linterCategory: LinterCategory.DYNAMIC_MANUAL_MEMO,
-  },
-  [ErrorCode.DYNAMIC_MANUAL_MEMO_DEPENDENCY_LIST]: {
-    code: ErrorCode.DYNAMIC_MANUAL_MEMO_DEPENDENCY_LIST,
-    severity: ErrorSeverity.InvalidReact,
-    reason: `Expected the dependency list of useMemo or useCallback to be an array literal`,
-    linterCategory: LinterCategory.DYNAMIC_MANUAL_MEMO,
-  },
-  [ErrorCode.COMPLEX_MANUAL_MEMO_DEPENDENCY_LIST_ENTRY]: {
-    code: ErrorCode.COMPLEX_MANUAL_MEMO_DEPENDENCY_LIST_ENTRY,
-    severity: ErrorSeverity.InvalidReact,
-    reason: `Expected the dependency list to be an array of simple expressions (e.g. \`x\`, \`x.y.z\`, \`x?.y?.z\`)`,
-    linterCategory: LinterCategory.DYNAMIC_MANUAL_MEMO,
-  },
-  [ErrorCode.INVALID_SET_STATE_IN_RENDER]: {
-    code: ErrorCode.INVALID_SET_STATE_IN_RENDER,
-    severity: ErrorSeverity.InvalidReact,
-    reason: 'Calling setState during render may trigger an infinite loop',
-    description:
-      'Calling setState during render will trigger another render, and can lead to infinite loops. (https://react.dev/reference/react/useState)',
-    linterCategory: LinterCategory.NO_SET_STATE_IN_RENDER,
-  },
-  [ErrorCode.INVALID_SET_STATE_IN_MEMO]: {
-    code: ErrorCode.INVALID_SET_STATE_IN_MEMO,
-    severity: ErrorSeverity.InvalidReact,
-    reason: 'Calling setState from useMemo may trigger an infinite loop',
-    description:
-      'Each time the memo callback is evaluated it will change state. This can cause a memoization dependency to change, running the memo function again and causing an infinite loop. Instead of setting state in useMemo(), prefer deriving the value during render. (https://react.dev/reference/react/useState)',
-    linterCategory: LinterCategory.NO_SET_STATE_IN_RENDER,
-  },
-  [ErrorCode.NO_DERIVED_COMPUTATIONS_IN_EFFECTS]: {
-    code: ErrorCode.NO_DERIVED_COMPUTATIONS_IN_EFFECTS,
-    severity: ErrorSeverity.InvalidReact,
-    reason:
-      'Values derived from props and state should be calculated during render, not in an effect. (https://react.dev/learn/you-might-not-need-an-effect#updating-state-based-on-props-or-state)',
-    linterCategory: LinterCategory.UNNECESSARY_EFFECTS,
-  },
-
-  /** Invalid writes */
-  [ErrorCode.INVALID_WRITE_GLOBAL]: {
-    code: ErrorCode.INVALID_WRITE_GLOBAL,
-    severity: ErrorSeverity.InvalidReact,
-    reason: 'Cannot reassign variables declared outside of the component/hook',
-    description:
-      'Reassigning this value during render is a form of side effect, which can cause unpredictable behavior depending on when the component happens to re-render. If this variable is used in rendering, use useState instead. Otherwise, consider updating it in an effect. (https://react.dev/reference/rules/components-and-hooks-must-be-pure#side-effects-must-run-outside-of-render)',
-    linterCategory: LinterCategory.INVALID_WRITE,
-  },
-  [ErrorCode.INVALID_WRITE_FROZEN_VALUE_JSX]: {
-    code: ErrorCode.INVALID_WRITE_FROZEN_VALUE_JSX,
-    severity: ErrorSeverity.InvalidReact,
-    reason:
-      'Modifying a value used previously in JSX is not allowed. Consider moving the modification before the JSX',
-    linterCategory: LinterCategory.INVALID_WRITE,
-  },
-  [ErrorCode.INVALID_WRITE_IMMUTABLE_VALUE_USE_CONTEXT]: {
-    code: ErrorCode.INVALID_WRITE_IMMUTABLE_VALUE_USE_CONTEXT,
-    severity: ErrorSeverity.InvalidReact,
-    reason: `Modifying a value returned from 'useContext()' is not allowed`,
-    linterCategory: LinterCategory.INVALID_WRITE,
-  },
-  [ErrorCode.INVALID_WRITE_IMMUTABLE_VALUE_KNOWN_SIGNATURE]: {
-    code: ErrorCode.INVALID_WRITE_IMMUTABLE_VALUE_KNOWN_SIGNATURE,
-    severity: ErrorSeverity.InvalidReact,
-    reason:
-      'Modifying a value returned from a function whose return value cannot be mutated',
-    linterCategory: LinterCategory.INVALID_WRITE,
-  },
-  [ErrorCode.INVALID_WRITE_IMMUTABLE_ARGS]: {
-    code: ErrorCode.INVALID_WRITE_IMMUTABLE_ARGS,
-    severity: ErrorSeverity.InvalidReact,
-    reason:
-      'Modifying component props or hook arguments is not allowed. Consider using a local variable instead',
-    linterCategory: LinterCategory.INVALID_WRITE,
-  },
-  [ErrorCode.INVALID_WRITE_STATE]: {
-    code: ErrorCode.INVALID_WRITE_STATE,
-    severity: ErrorSeverity.InvalidReact,
-    reason:
-      "Modifying a value returned from 'useState()', which cannot be modified directly. Use the setter function to update instead",
-    linterCategory: LinterCategory.INVALID_WRITE,
-  },
-  [ErrorCode.INVALID_WRITE_REDUCER_STATE]: {
-    code: ErrorCode.INVALID_WRITE_REDUCER_STATE,
-    severity: ErrorSeverity.InvalidReact,
-    reason:
-      "Modifying a value returned from 'useReducer()', which cannot be modified directly. Use the dispatch function to update instead",
-    linterCategory: LinterCategory.INVALID_WRITE,
-  },
-  [ErrorCode.INVALID_WRITE_EFFECT_DEPENDENCY]: {
-    code: ErrorCode.INVALID_WRITE_EFFECT_DEPENDENCY,
-    severity: ErrorSeverity.InvalidReact,
-    reason:
-      'Modifying a value used previously in an effect function or as an effect dependency is not allowed. Consider moving the modification before calling useEffect()',
-    linterCategory: LinterCategory.INVALID_WRITE,
-  },
-  [ErrorCode.INVALID_WRITE_HOOK_CAPTURED]: {
-    code: ErrorCode.INVALID_WRITE_HOOK_CAPTURED,
-    severity: ErrorSeverity.InvalidReact,
-    reason:
-      'Modifying a value previously passed as an argument to a hook is not allowed. Consider moving the modification before calling the hook',
-    linterCategory: LinterCategory.INVALID_WRITE,
-  },
-  [ErrorCode.INVALID_WRITE_HOOK_RETURN]: {
-    code: ErrorCode.INVALID_WRITE_HOOK_RETURN,
-    severity: ErrorSeverity.InvalidReact,
-    reason:
-      'Modifying a value returned from a hook is not allowed. Consider moving the modification into the hook where the value is constructed',
-    linterCategory: LinterCategory.INVALID_WRITE,
-  },
-  [ErrorCode.INVALID_ACCESS_BEFORE_INIT]: {
-    code: ErrorCode.INVALID_ACCESS_BEFORE_INIT,
-    severity: ErrorSeverity.InvalidReact,
-    reason: 'Cannot access variable before it is declared',
-    description: `Reading a variable before it is initialized will prevent the earlier access from updating when this value changes over time. Instead, move the variable access to after it has been initialized`,
-    linterCategory: LinterCategory.INVALID_WRITE,
-  },
-  [ErrorCode.INVALID_WRITE_GENERIC]: {
-    code: ErrorCode.INVALID_WRITE_GENERIC,
-    severity: ErrorSeverity.InvalidReact,
-    reason: 'This modifies a variable that React considers immutable',
-    linterCategory: LinterCategory.INVALID_WRITE,
-  },
-
-  /** Compiler Config */
-  [ErrorCode.DYNAMIC_GATING_IS_NOT_IDENTIFIER]: {
-    code: ErrorCode.DYNAMIC_GATING_IS_NOT_IDENTIFIER,
-    severity: ErrorSeverity.InvalidReact,
-    reason: 'Dynamic gating directive is not a valid JavaScript identifier',
-    linterCategory: LinterCategory.COMPILER_CONFIG,
-  },
-  [ErrorCode.DYNAMIC_GATING_MULTIPLE_DIRECTIVES]: {
-    code: ErrorCode.DYNAMIC_GATING_MULTIPLE_DIRECTIVES,
-    severity: ErrorSeverity.InvalidReact,
-    reason: 'Expected a single dynamic gating directive',
-    linterCategory: LinterCategory.COMPILER_CONFIG,
-  },
-  [ErrorCode.FILENAME_NOT_SET]: {
-    code: ErrorCode.FILENAME_NOT_SET,
-    severity: ErrorSeverity.InvalidConfig,
-    reason: `Expected a filename but found none`,
-    description:
-      "When the 'sources' config options is specified, the React compiler will only compile files with a name",
-    linterCategory: LinterCategory.COMPILER_CONFIG,
-  },
-
-  /** Effect dependencies */
-  [ErrorCode.MEMOIZED_EFFECT_DEPENDENCIES]: {
-    code: ErrorCode.MEMOIZED_EFFECT_DEPENDENCIES,
-    reason:
-      'React Compiler has skipped optimizing this component because the effect dependencies could not be memoized. Unmemoized effect dependencies can trigger an infinite loop or other unexpected behavior',
-    severity: ErrorSeverity.CannotPreserveMemoization,
-    linterCategory: LinterCategory.MEMOIZED_DEPENDENCIES,
-  },
-
-  /** Invalid / unsupported syntax */
-  [ErrorCode.INVALID_SYNTAX_MULTIPLE_DEFAULTS]: {
-    code: ErrorCode.INVALID_SYNTAX_MULTIPLE_DEFAULTS,
-    reason: `Expected at most one \`default\` branch in a switch statement, this code should have failed to parse`,
-    severity: ErrorSeverity.InvalidJS,
-    linterCategory: LinterCategory.UNSUPPORTED_SYNTAX,
-  },
-  [ErrorCode.INVALID_SYNTAX_REASSIGNED_CONST]: {
-    code: ErrorCode.INVALID_SYNTAX_REASSIGNED_CONST,
-    reason: `Expect \`const\` declaration not to be reassigned`,
-    severity: ErrorSeverity.InvalidJS,
-    linterCategory: LinterCategory.UNSUPPORTED_SYNTAX,
-  },
-  [ErrorCode.INVALID_SYNTAX_BAD_VARIABLE_DECL]: {
-    code: ErrorCode.INVALID_SYNTAX_BAD_VARIABLE_DECL,
-    reason: `Expected variable declaration to be an identifier if no initializer was provided`,
-    severity: ErrorSeverity.InvalidJS,
-    linterCategory: LinterCategory.UNSUPPORTED_SYNTAX,
-  },
-  [ErrorCode.UNSUPPORTED_WITH]: {
-    code: ErrorCode.UNSUPPORTED_WITH,
-    reason: `JavaScript 'with' syntax is not supported`,
-    description: `'with' syntax is considered deprecated and removed from JavaScript standards, consider alternatives`,
-    severity: ErrorSeverity.UnsupportedJS,
-    linterCategory: LinterCategory.UNSUPPORTED_SYNTAX,
-  },
-  [ErrorCode.UNSUPPORTED_INNER_CLASS]: {
-    code: ErrorCode.UNSUPPORTED_INNER_CLASS,
-    reason: 'Inline `class` declarations are not supported',
-    description: `Move class declarations outside of components/hooks`,
-    severity: ErrorSeverity.UnsupportedJS,
-    linterCategory: LinterCategory.UNSUPPORTED_SYNTAX,
-  },
-  [ErrorCode.INVALID_IMPORT_EXPORT]: {
-    code: ErrorCode.INVALID_IMPORT_EXPORT,
-    reason:
-      'JavaScript `import` and `export` statements may only appear at the top level of a module',
-    severity: ErrorSeverity.InvalidJS,
-    linterCategory: LinterCategory.UNSUPPORTED_SYNTAX,
-  },
-  [ErrorCode.INVALID_TS_NAMESPACE]: {
-    code: ErrorCode.INVALID_TS_NAMESPACE,
-    reason:
-      'TypeScript `namespace` statements may only appear at the top level of a module',
-    severity: ErrorSeverity.InvalidJS,
-    linterCategory: LinterCategory.UNSUPPORTED_SYNTAX,
-  },
-  [ErrorCode.UNSUPPORTED_NEW_EXPRESSION]: {
-    code: ErrorCode.UNSUPPORTED_NEW_EXPRESSION,
-    reason: `Expected an expression as the \`new\` expression receiver (v8 intrinsics are not supported)`,
-    severity: ErrorSeverity.InvalidJS,
-    linterCategory: LinterCategory.UNSUPPORTED_SYNTAX,
-  },
-  [ErrorCode.UNSUPPORTED_EMPTY_SEQUENCE_EXPRESSION]: {
-    code: ErrorCode.UNSUPPORTED_EMPTY_SEQUENCE_EXPRESSION,
-    reason: `Expected sequence expression to have at least one expression`,
-    severity: ErrorSeverity.InvalidJS,
-    linterCategory: LinterCategory.UNSUPPORTED_SYNTAX,
-  },
-  [ErrorCode.INVALID_QUASI_LENGTHS]: {
-    code: ErrorCode.INVALID_QUASI_LENGTHS,
-    reason: `Unexpected quasi and subexpression lengths in template literal`,
-    severity: ErrorSeverity.InvalidJS,
-    linterCategory: LinterCategory.UNSUPPORTED_SYNTAX,
-  },
-  [ErrorCode.INVALID_SYNTAX_DELETE_EXPRESSION]: {
-    code: ErrorCode.INVALID_SYNTAX_DELETE_EXPRESSION,
-    reason: `Only object properties can be deleted`,
-    severity: ErrorSeverity.InvalidJS,
-    linterCategory: LinterCategory.UNSUPPORTED_SYNTAX,
-  },
-  [ErrorCode.UNSUPPORTED_THROW_EXPRESSION]: {
-    code: ErrorCode.UNSUPPORTED_THROW_EXPRESSION,
-    reason: `Throw expressions are not supported`,
-    severity: ErrorSeverity.InvalidJS,
-    linterCategory: LinterCategory.UNSUPPORTED_SYNTAX,
-  },
-  [ErrorCode.INVALID_JSX_NAMESPACED_NAME]: {
-    code: ErrorCode.INVALID_JSX_NAMESPACED_NAME,
-    reason: `Expected JSXNamespacedName to have no colons in the namespace or name`,
-    severity: ErrorSeverity.InvalidJS,
-    linterCategory: LinterCategory.UNSUPPORTED_SYNTAX,
-  },
-  [ErrorCode.UNSUPPORTED_EVAL]: {
-    code: ErrorCode.UNSUPPORTED_EVAL,
-    reason: `The 'eval' function is not supported`,
-    description:
-      'Eval is an anti-pattern in JavaScript, and the code executed cannot be evaluated by React Compiler',
-    severity: ErrorSeverity.UnsupportedJS,
-    linterCategory: LinterCategory.UNSUPPORTED_SYNTAX,
-  },
-  [ErrorCode.INVALID_SYNTAX_RESERVED_VARIABLE_NAME]: {
-    code: ErrorCode.INVALID_SYNTAX_RESERVED_VARIABLE_NAME,
-    reason: 'Expected a non-reserved identifier name',
-    severity: ErrorSeverity.InvalidJS,
-    linterCategory: LinterCategory.UNSUPPORTED_SYNTAX,
-  },
-  [ErrorCode.INVALID_JAVASCRIPT_AST]: {
-    code: ErrorCode.INVALID_JAVASCRIPT_AST,
-    reason: 'Encountered invalid JavaScript',
-    severity: ErrorSeverity.InvalidJS,
-    linterCategory: LinterCategory.UNSUPPORTED_SYNTAX,
-  },
-  [ErrorCode.BAILOUT_ESLINT_SUPPRESSION]: {
-    code: ErrorCode.BAILOUT_ESLINT_SUPPRESSION,
-    reason:
-      'React Compiler has skipped optimizing this component because one or more React ESLint rules were disabled',
-    description:
-      'React Compiler only works when your components follow all the rules of React, disabling them may result in unexpected or incorrect behavior',
-    severity: ErrorSeverity.InvalidReact,
-    linterCategory: LinterCategory.UNSUPPORTED_SYNTAX,
-  },
-  [ErrorCode.MANUAL_MEMO_REMOVED]: {
-    code: ErrorCode.MANUAL_MEMO_REMOVED,
-    reason:
-      'Compilation skipped because existing memoization could not be preserved',
-    description:
-      'React Compiler has skipped optimizing this component because the existing manual memoization could not be preserved. This value was memoized in source but not in compilation output',
-    severity: ErrorSeverity.CannotPreserveMemoization,
-    linterCategory: LinterCategory.TODO_SYNTAX,
-  },
-
-  /**
-   * This is left vague as fire is very experimental
-   */
-  [ErrorCode.CANNOT_COMPILE_FIRE]: {
-    code: ErrorCode.CANNOT_COMPILE_FIRE,
-    reason: 'Cannot compile `fire`',
-    severity: ErrorSeverity.InvalidReact,
-    linterCategory: LinterCategory.UNSUPPORTED_SYNTAX,
-  },
-  [ErrorCode.DID_NOT_INFER_DEPS]: {
-    code: ErrorCode.DID_NOT_INFER_DEPS,
-    reason:
-      'Cannot infer dependencies of this effect. This will break your build!',
-    description:
-      'To resolve, either pass a dependency array or fix reported compiler bailout diagnostics',
-    severity: ErrorSeverity.InvalidReact,
-    linterCategory: LinterCategory.UNSUPPORTED_SYNTAX,
-  },
-
-  [ErrorCode.BAILOUT_FLOW_SUPPRESSION]: {
-    code: ErrorCode.BAILOUT_FLOW_SUPPRESSION,
-    reason:
-      'React Compiler has skipped optimizing this component because one or more React rule violations were reported by Flow',
-    description:
-      'React Compiler only works when your components follow all the rules of React, disabling them may result in unexpected or incorrect behavior',
-    severity: ErrorSeverity.InvalidReact,
-    linterCategory: LinterCategory.UNSUPPORTED_SYNTAX,
-  },
-
-  /** Syntax React Compiler may eventually support */
-  [ErrorCode.TODO_CONFLICTING_FBT_IDENTIFIER]: {
-    code: ErrorCode.TODO_CONFLICTING_FBT_IDENTIFIER,
-    reason: 'Support local variables named `fbt`',
-    description:
-      'Local variables named `fbt` may conflict with the fbt plugin and are not yet supported',
-    severity: ErrorSeverity.Todo,
-    linterCategory: LinterCategory.TODO_SYNTAX,
-  },
-  [ErrorCode.TODO_DUPLICATE_FBT_TAGS]: {
-    code: ErrorCode.TODO_DUPLICATE_FBT_TAGS,
-    reason: 'Support duplicate fbt tags',
-    severity: ErrorSeverity.Todo,
-    linterCategory: LinterCategory.TODO_SYNTAX,
-  },
-  [ErrorCode.UNKNOWN_FUNCTION_PARAMETERS]: {
-    code: ErrorCode.UNKNOWN_FUNCTION_PARAMETERS,
-    severity: ErrorSeverity.Todo,
-    reason: 'Currently unsupported function parameter syntax',
-    linterCategory: LinterCategory.TODO_SYNTAX,
-  },
-  [ErrorCode.MANUAL_MEMO_MUTATED_LATER]: {
-    code: ErrorCode.MANUAL_MEMO_MUTATED_LATER,
-    reason:
-      'Compilation skipped because existing memoization could not be preserved',
-    description: [
-      'React Compiler has skipped optimizing this component because the existing manual memoization could not be preserved. ',
-      'This dependency may be mutated later, which could cause the value to change unexpectedly',
-    ].join(''),
-    severity: ErrorSeverity.CannotPreserveMemoization,
-    linterCategory: LinterCategory.UNSUPPORTED_SYNTAX,
-  },
-  [ErrorCode.MANUAL_MEMO_DEPENDENCIES_CONFLICT]: {
-    code: ErrorCode.MANUAL_MEMO_DEPENDENCIES_CONFLICT,
-    reason:
-      'Compilation skipped because existing memoization could not be preserved',
-    description:
-      'React Compiler has skipped optimizing this component because the existing manual memoization could not be preserved. ' +
-      'The inferred dependencies did not match the manually specified dependencies, which could cause the value to change more or less frequently than expected',
-    severity: ErrorSeverity.CannotPreserveMemoization,
-    linterCategory: LinterCategory.UNSUPPORTED_SYNTAX,
-  },
-};

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

@@ -1,34 +0,0 @@
-export enum ErrorSeverity {
-  /**
-   * Invalid JS syntax, or valid syntax that is semantically invalid which may indicate some
-   * misunderstanding on the user’s part.
-   */
-  InvalidJS = 'InvalidJS',
-  /**
-   * JS syntax that is not supported and which we do not plan to support. Developers should
-   * rewrite to use supported forms.
-   */
-  UnsupportedJS = 'UnsupportedJS',
-  /**
-   * Code that breaks the rules of React.
-   */
-  InvalidReact = 'InvalidReact',
-  /**
-   * Incorrect configuration of the compiler.
-   */
-  InvalidConfig = 'InvalidConfig',
-  /**
-   * Code that can reasonably occur and that doesn't break any rules, but is unsafe to preserve
-   * memoization.
-   */
-  CannotPreserveMemoization = 'CannotPreserveMemoization',
-  /**
-   * Unhandled syntax that we don't support yet.
-   */
-  Todo = 'Todo',
-  /**
-   * An unexpected internal error in the compiler that indicates critical issues that can panic
-   * the compiler.
-   */
-  Invariant = 'Invariant',
-}

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

@@ -90,10 +90,13 @@ export function Ok<T>(val: T): OkImpl<T> {
 }
 
 class OkImpl<T> implements Result<T, never> {
-  constructor(private val: T) {}
+  #val: T;
+  constructor(val: T) {
+    this.#val = val;
+  }
 
   map<U>(fn: (val: T) => U): Result<U, never> {
-    return new OkImpl(fn(this.val));
+    return new OkImpl(fn(this.#val));
   }
 
   mapErr<F>(_fn: (val: never) => F): Result<T, F> {
@@ -101,15 +104,15 @@ class OkImpl<T> implements Result<T, never> {
   }
 
   mapOr<U>(_fallback: U, fn: (val: T) => U): U {
-    return fn(this.val);
+    return fn(this.#val);
   }
 
   mapOrElse<U>(_fallback: () => U, fn: (val: T) => U): U {
-    return fn(this.val);
+    return fn(this.#val);
   }
 
   andThen<U>(fn: (val: T) => Result<U, never>): Result<U, never> {
-    return fn(this.val);
+    return fn(this.#val);
   }
 
   and<U>(res: Result<U, never>): Result<U, never> {
@@ -133,30 +136,30 @@ class OkImpl<T> implements Result<T, never> {
   }
 
   expect(_msg: string): T {
-    return this.val;
+    return this.#val;
   }
 
   expectErr(msg: string): never {
-    throw new Error(`${msg}: ${this.val}`);
+    throw new Error(`${msg}: ${this.#val}`);
   }
 
   unwrap(): T {
-    return this.val;
+    return this.#val;
   }
 
   unwrapOr(_fallback: T): T {
-    return this.val;
+    return this.#val;
   }
 
   unwrapOrElse(_fallback: (val: never) => T): T {
-    return this.val;
+    return this.#val;
   }
 
   unwrapErr(): never {
-    if (this.val instanceof Error) {
-      throw this.val;
+    if (this.#val instanceof Error) {
+      throw this.#val;
     }
-    throw new Error(`Can't unwrap \`Ok\` to \`Err\`: ${this.val}`);
+    throw new Error(`Can't unwrap \`Ok\` to \`Err\`: ${this.#val}`);
   }
 }
 
@@ -165,14 +168,17 @@ export function Err<E>(val: E): ErrImpl<E> {
 }
 
 class ErrImpl<E> implements Result<never, E> {
-  constructor(private val: E) {}
+  #val: E;
+  constructor(val: E) {
+    this.#val = val;
+  }
 
   map<U>(_fn: (val: never) => U): Result<U, E> {
     return this;
   }
 
   mapErr<F>(fn: (val: E) => F): Result<never, F> {
-    return new ErrImpl(fn(this.val));
+    return new ErrImpl(fn(this.#val));
   }
 
   mapOr<U>(fallback: U, _fn: (val: never) => U): U {
@@ -196,7 +202,7 @@ class ErrImpl<E> implements Result<never, E> {
   }
 
   orElse<F>(fn: (val: E) => ErrImpl<F>): Result<never, F> {
-    return fn(this.val);
+    return fn(this.#val);
   }
 
   isOk(): this is OkImpl<never> {
@@ -208,18 +214,18 @@ class ErrImpl<E> implements Result<never, E> {
   }
 
   expect(msg: string): never {
-    throw new Error(`${msg}: ${this.val}`);
+    throw new Error(`${msg}: ${this.#val}`);
   }
 
   expectErr(_msg: string): E {
-    return this.val;
+    return this.#val;
   }
 
   unwrap(): never {
-    if (this.val instanceof Error) {
-      throw this.val;
+    if (this.#val instanceof Error) {
+      throw this.#val;
     }
-    throw new Error(`Can't unwrap \`Err\` to \`Ok\`: ${this.val}`);
+    throw new Error(`Can't unwrap \`Err\` to \`Ok\`: ${this.#val}`);
   }
 
   unwrapOr<T>(fallback: T): T {
@@ -227,10 +233,10 @@ class ErrImpl<E> implements Result<never, E> {
   }
 
   unwrapOrElse<T>(fallback: (val: E) => T): T {
-    return fallback(this.val);
+    return fallback(this.#val);
   }
 
   unwrapErr(): E {
-    return this.val;
+    return this.#val;
   }
 }

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

@@ -6,7 +6,12 @@
  */
 
 import * as t from '@babel/types';
-import {CompilerError, CompilerErrorDetail} from '../CompilerError';
+import {
+  CompilerError,
+  CompilerErrorDetail,
+  ErrorCategory,
+  ErrorSeverity,
+} from '../CompilerError';
 import {computeUnconditionalBlocks} from '../HIR/ComputeUnconditionalBlocks';
 import {isHookName} from '../HIR/Environment';
 import {
@@ -23,7 +28,6 @@ import {
 } from '../HIR/visitors';
 import {assertExhaustive} from '../Utils/utils';
 import {Result} from '../Utils/Result';
-import {ErrorCode, ErrorCodeDetails} from '../Utils/CompilerErrorCodes';
 
 /**
  * Represents the possible kinds of value which may be stored at a given Place during
@@ -108,6 +112,8 @@ export function validateHooksUsage(
     // Once a particular hook has a conditional call error, don't report any further issues for this hook
     setKind(place, Kind.Error);
 
+    const reason =
+      'Hooks must always be called in a consistent order, and may not be called conditionally. See the Rules of Hooks (https://react.dev/warnings/invalid-hook-call-warning)';
     const previousError =
       typeof place.loc !== 'symbol' ? errorsByPlace.get(place.loc) : undefined;
 
@@ -115,15 +121,16 @@ export function validateHooksUsage(
      * In some circumstances such as optional calls, we may first encounter a "hook may not be referenced as normal values" error.
      * If that same place is also used as a conditional call, upgrade the error to a conditonal hook error
      */
-    if (
-      previousError === undefined ||
-      previousError.reason !==
-        ErrorCodeDetails[ErrorCode.HOOK_CALL_STATIC].reason
-    ) {
+    if (previousError === undefined || previousError.reason !== reason) {
       recordError(
         place.loc,
-        CompilerErrorDetail.fromCode(ErrorCode.HOOK_CALL_STATIC, {
+        new CompilerErrorDetail({
+          category: ErrorCategory.Hooks,
+          description: null,
+          reason,
           loc: place.loc,
+          severity: ErrorSeverity.InvalidReact,
+          suggestions: null,
         }),
       );
     }
@@ -134,8 +141,14 @@ export function validateHooksUsage(
     if (previousError === undefined) {
       recordError(
         place.loc,
-        CompilerErrorDetail.fromCode(ErrorCode.HOOK_INVALID_REFERENCE, {
+        new CompilerErrorDetail({
+          category: ErrorCategory.Hooks,
+          description: null,
+          reason:
+            'Hooks may not be referenced as normal values, they must be called. See https://react.dev/reference/rules/react-calls-components-and-hooks#never-pass-around-hooks-as-regular-values',
           loc: place.loc,
+          severity: ErrorSeverity.InvalidReact,
+          suggestions: null,
         }),
       );
     }
@@ -146,12 +159,15 @@ export function validateHooksUsage(
     if (previousError === undefined) {
       recordError(
         place.loc,
-        CompilerErrorDetail.fromCode(
-          ErrorCodeDetails[ErrorCode.HOOK_CALL_REACTIVE].code,
-          {
-            loc: place.loc,
-          },
-        ),
+        new CompilerErrorDetail({
+          category: ErrorCategory.Hooks,
+          description: null,
+          reason:
+            'Hooks must be the same function on every render, but this value may change over time to a different function. See https://react.dev/reference/rules/react-calls-components-and-hooks#dont-dynamically-use-hooks',
+          loc: place.loc,
+          severity: ErrorSeverity.InvalidReact,
+          suggestions: null,
+        }),
       );
     }
   }
@@ -434,10 +450,17 @@ function visitFunctionExpression(errors: CompilerError, fn: HIRFunction): void {
               : instr.value.property;
           const hookKind = getHookKind(fn.env, callee.identifier);
           if (hookKind != null) {
-            errors.pushErrorCode(ErrorCode.HOOK_CALL_NOT_TOP_LEVEL, {
-              loc: callee.loc,
-              description: `Cannot call ${hookKind === 'Custom' ? 'hook' : hookKind} within a function expression`,
-            });
+            errors.pushErrorDetail(
+              new CompilerErrorDetail({
+                category: ErrorCategory.Hooks,
+                severity: ErrorSeverity.InvalidReact,
+                reason:
+                  'Hooks must be called at the top level in the body of a function component or custom hook, and may not be called within function expressions. See the Rules of Hooks (https://react.dev/warnings/invalid-hook-call-warning)',
+                loc: callee.loc,
+                description: `Cannot call ${hookKind === 'Custom' ? 'hook' : hookKind} within a function expression`,
+                suggestions: null,
+              }),
+            );
           }
           break;
         }

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

@@ -5,25 +5,22 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-import {CompilerDiagnostic, CompilerError, Effect} from '..';
+import {CompilerDiagnostic, CompilerError, Effect, ErrorSeverity} from '..';
+import {ErrorCategory} from '../CompilerError';
 import {HIRFunction, IdentifierId, Place} from '../HIR';
 import {
   eachInstructionLValue,
   eachInstructionValueOperand,
   eachTerminalOperand,
 } from '../HIR/visitors';
-import {getFunctionCallSignature} from '../Inference/InferReferenceEffects';
-import {ErrorCode} from '../Utils/CompilerErrorCodes';
-import {Ok, Result} from '../Utils/Result';
+import {getFunctionCallSignature} from '../Inference/InferMutationAliasingEffects';
 
 /**
  * Validates that local variables cannot be reassigned after render.
  * This prevents a category of bugs in which a closure captures a
  * binding from one render but does not update
  */
-export function validateLocalsNotReassignedAfterRender(
-  fn: HIRFunction,
-): Result<void, CompilerError> {
+export function validateLocalsNotReassignedAfterRender(fn: HIRFunction): void {
   const contextVariables = new Set<IdentifierId>();
   const reassignment = getContextReassignment(
     fn,
@@ -39,15 +36,19 @@ export function validateLocalsNotReassignedAfterRender(
         ? `\`${reassignment.identifier.name.value}\``
         : 'variable';
     errors.pushDiagnostic(
-      CompilerDiagnostic.fromCode(ErrorCode.REASSIGN_AFTER_RENDER).withDetail({
+      CompilerDiagnostic.create({
+        category: ErrorCategory.Immutability,
+        severity: ErrorSeverity.InvalidReact,
+        reason: 'Cannot reassign variable after render completes',
+        description: `Reassigning ${variable} after render has completed can cause inconsistent behavior on subsequent renders. Consider using state instead.`,
+      }).withDetail({
         kind: 'error',
         loc: reassignment.loc,
         message: `Cannot reassign ${variable} after render completes`,
       }),
     );
-    return errors.asResult();
+    throw errors;
   }
-  return Ok(undefined);
 }
 
 function getContextReassignment(
@@ -91,9 +92,13 @@ function getContextReassignment(
                   ? `\`${reassignment.identifier.name.value}\``
                   : 'variable';
               errors.pushDiagnostic(
-                CompilerDiagnostic.fromCode(
-                  ErrorCode.REASSIGN_IN_ASYNC,
-                ).withDetail({
+                CompilerDiagnostic.create({
+                  category: ErrorCategory.Immutability,
+                  severity: ErrorSeverity.InvalidReact,
+                  reason: 'Cannot reassign variable in async function',
+                  description:
+                    'Reassigning a variable in an async function can cause inconsistent behavior on subsequent renders. Consider using state instead',
+                }).withDetail({
                   kind: 'error',
                   loc: reassignment.loc,
                   message: `Cannot reassign ${variable}`,

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

@@ -5,7 +5,8 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-import {CompilerError} from '..';
+import {CompilerError, ErrorSeverity} from '..';
+import {ErrorCategory} from '../CompilerError';
 import {
   Identifier,
   Instruction,
@@ -22,7 +23,6 @@ import {
   ReactiveFunctionVisitor,
   visitReactiveFunction,
 } from '../ReactiveScopes/visitors';
-import {ErrorCode} from '../Utils/CompilerErrorCodes';
 import {Result} from '../Utils/Result';
 
 /**
@@ -109,8 +109,13 @@ class Visitor extends ReactiveFunctionVisitor<CompilerError> {
           isUnmemoized(deps.identifier, this.scopes))
       ) {
         state.push({
-          errorCode: ErrorCode.MEMOIZED_EFFECT_DEPENDENCIES,
+          category: ErrorCategory.EffectDependencies,
+          reason:
+            'React Compiler has skipped optimizing this component because the effect dependencies could not be memoized. Unmemoized effect dependencies can trigger an infinite loop or other unexpected behavior',
+          description: null,
+          severity: ErrorSeverity.CannotPreserveMemoization,
           loc: typeof instruction.loc !== 'symbol' ? instruction.loc : null,
+          suggestions: null,
         });
       }
     }

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

@@ -5,10 +5,10 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-import {CompilerError, EnvironmentConfig} from '..';
+import {CompilerError, EnvironmentConfig, ErrorSeverity} from '..';
+import {ErrorCategory} from '../CompilerError';
 import {HIRFunction, IdentifierId} from '../HIR';
 import {DEFAULT_GLOBALS} from '../HIR/Globals';
-import {ErrorCode} from '../Utils/CompilerErrorCodes';
 import {Result} from '../Utils/Result';
 
 export function validateNoCapitalizedCalls(
@@ -34,6 +34,8 @@ export function validateNoCapitalizedCalls(
   const errors = new CompilerError();
   const capitalLoadGlobals = new Map<IdentifierId, string>();
   const capitalizedProperties = new Map<IdentifierId, string>();
+  const reason =
+    'Capitalized functions are reserved for components, which must be invoked with JSX. If this is a component, render it with JSX. Otherwise, ensure that it has no hook calls and rename it to begin with a lowercase letter. Alternatively, if you know for a fact that this function is not a component, you can allowlist it via the compiler config';
   for (const [, block] of fn.body.blocks) {
     for (const {lvalue, value} of block.instructions) {
       switch (value.kind) {
@@ -54,9 +56,12 @@ export function validateNoCapitalizedCalls(
           const calleeIdentifier = value.callee.identifier.id;
           const calleeName = capitalLoadGlobals.get(calleeIdentifier);
           if (calleeName != null) {
-            errors.pushErrorCode(ErrorCode.CAPITALIZED_CALLS, {
+            CompilerError.throwInvalidReact({
+              category: ErrorCategory.CapitalizedCalls,
+              reason,
               description: `${calleeName} may be a component.`,
               loc: value.loc,
+              suggestions: null,
             });
           }
           break;
@@ -75,9 +80,13 @@ export function validateNoCapitalizedCalls(
           const propertyIdentifier = value.property.identifier.id;
           const propertyName = capitalizedProperties.get(propertyIdentifier);
           if (propertyName != null) {
-            errors.pushErrorCode(ErrorCode.CAPITALIZED_CALLS, {
+            errors.push({
+              category: ErrorCategory.CapitalizedCalls,
+              severity: ErrorSeverity.InvalidReact,
+              reason,
               description: `${propertyName} may be a component.`,
               loc: value.loc,
+              suggestions: null,
             });
           }
           break;

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

@@ -5,7 +5,8 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-import {CompilerError, SourceLocation} from '..';
+import {CompilerError, ErrorSeverity, SourceLocation} from '..';
+import {ErrorCategory} from '../CompilerError';
 import {
   ArrayExpression,
   BlockId,
@@ -19,8 +20,6 @@ import {
   eachInstructionValueOperand,
   eachTerminalOperand,
 } from '../HIR/visitors';
-import {ErrorCode} from '../Utils/CompilerErrorCodes';
-import {Result} from '../Utils/Result';
 
 /**
  * Validates that useEffect is not used for derived computations which could/should
@@ -45,9 +44,7 @@ import {Result} from '../Utils/Result';
  * const fullName = firstName + ' ' + lastName;
  * ```
  */
-export function validateNoDerivedComputationsInEffects(
-  fn: HIRFunction,
-): Result<void, CompilerError> {
+export function validateNoDerivedComputationsInEffects(fn: HIRFunction): void {
   const candidateDependencies: Map<IdentifierId, ArrayExpression> = new Map();
   const functions: Map<IdentifierId, FunctionExpression> = new Map();
   const locals: Map<IdentifierId, IdentifierId> = new Map();
@@ -100,7 +97,9 @@ export function validateNoDerivedComputationsInEffects(
       }
     }
   }
-  return errors.asResult();
+  if (errors.hasErrors()) {
+    throw errors;
+  }
 }
 
 function validateEffect(
@@ -220,6 +219,14 @@ function validateEffect(
   }
 
   for (const loc of setStateLocations) {
-    errors.pushErrorCode(ErrorCode.NO_DERIVED_COMPUTATIONS_IN_EFFECTS, {loc});
+    errors.push({
+      category: ErrorCategory.EffectDerivationsOfState,
+      reason:
+        'Values derived from props and state should be calculated during render, not in an effect. (https://react.dev/learn/you-might-not-need-an-effect#updating-state-based-on-props-or-state)',
+      description: null,
+      severity: ErrorSeverity.InvalidReact,
+      loc,
+      suggestions: null,
+    });
   }
 }

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

@@ -5,13 +5,11 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-import {CompilerDiagnostic, CompilerError, Effect} from '..';
-import {ErrorCode} from '../CompilerError';
+import {CompilerDiagnostic, CompilerError, Effect, ErrorSeverity} from '..';
+import {ErrorCategory} from '../CompilerError';
 import {
-  FunctionEffect,
   HIRFunction,
   IdentifierId,
-  isMutableEffect,
   isRefOrRefLikeMutableType,
   Place,
 } from '../HIR';
@@ -19,8 +17,8 @@ import {
   eachInstructionValueOperand,
   eachTerminalOperand,
 } from '../HIR/visitors';
+import {AliasingEffect} from '../Inference/AliasingEffects';
 import {Result} from '../Utils/Result';
-import {Iterable_some} from '../Utils/utils';
 
 /**
  * Validates that functions with known mutations (ie due to types) cannot be passed
@@ -51,14 +49,14 @@ export function validateNoFreezingKnownMutableFunctions(
   const errors = new CompilerError();
   const contextMutationEffects: Map<
     IdentifierId,
-    Extract<FunctionEffect, {kind: 'ContextMutation'}>
+    Extract<AliasingEffect, {kind: 'Mutate'} | {kind: 'MutateTransitive'}>
   > = new Map();
 
   function visitOperand(operand: Place): void {
     if (operand.effect === Effect.Freeze) {
       const effect = contextMutationEffects.get(operand.identifier.id);
       if (effect != null) {
-        const place = [...effect.places][0];
+        const place = effect.value;
         const variable =
           place != null &&
           place.identifier.name != null &&
@@ -66,7 +64,12 @@ export function validateNoFreezingKnownMutableFunctions(
             ? `\`${place.identifier.name.value}\``
             : 'a local variable';
         errors.pushDiagnostic(
-          CompilerDiagnostic.fromCode(ErrorCode.WRITE_AFTER_RENDER)
+          CompilerDiagnostic.create({
+            category: ErrorCategory.Immutability,
+            severity: ErrorSeverity.InvalidReact,
+            reason: 'Cannot modify local variables after render completes',
+            description: `This argument is a function which may reassign or mutate ${variable} after render, which can cause inconsistent behavior on subsequent renders. Consider using state instead.`,
+          })
             .withDetail({
               kind: 'error',
               loc: operand.loc,
@@ -74,7 +77,7 @@ export function validateNoFreezingKnownMutableFunctions(
             })
             .withDetail({
               kind: 'error',
-              loc: effect.loc,
+              loc: effect.value.loc,
               message: `This modifies ${variable}`,
             }),
         );
@@ -105,27 +108,7 @@ export function validateNoFreezingKnownMutableFunctions(
           break;
         }
         case 'FunctionExpression': {
-          const knownMutation = (value.loweredFunc.func.effects ?? []).find(
-            effect => {
-              return (
-                effect.kind === 'ContextMutation' &&
-                (effect.effect === Effect.Store ||
-                  effect.effect === Effect.Mutate) &&
-                Iterable_some(effect.places, place => {
-                  return (
-                    isMutableEffect(place.effect, place.loc) &&
-                    !isRefOrRefLikeMutableType(place.identifier.type)
-                  );
-                })
-              );
-            },
-          );
-          if (knownMutation && knownMutation.kind === 'ContextMutation') {
-            contextMutationEffects.set(lvalue.identifier.id, knownMutation);
-          } else if (
-            fn.env.config.enableNewMutationAliasingModel &&
-            value.loweredFunc.func.aliasingEffects != null
-          ) {
+          if (value.loweredFunc.func.aliasingEffects != null) {
             const context = new Set(
               value.loweredFunc.func.context.map(p => p.identifier.id),
             );
@@ -146,12 +129,7 @@ export function validateNoFreezingKnownMutableFunctions(
                     context.has(effect.value.identifier.id) &&
                     !isRefOrRefLikeMutableType(effect.value.identifier.type)
                   ) {
-                    contextMutationEffects.set(lvalue.identifier.id, {
-                      kind: 'ContextMutation',
-                      effect: Effect.Mutate,
-                      loc: effect.value.loc,
-                      places: new Set([effect.value]),
-                    });
+                    contextMutationEffects.set(lvalue.identifier.id, effect);
                     break effects;
                   }
                   break;

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

@@ -5,10 +5,10 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-import {CompilerDiagnostic, CompilerError} from '..';
+import {CompilerDiagnostic, CompilerError, ErrorSeverity} from '..';
+import {ErrorCategory} from '../CompilerError';
 import {HIRFunction} from '../HIR';
-import {getFunctionCallSignature} from '../Inference/InferReferenceEffects';
-import {ErrorCode} from '../Utils/CompilerErrorCodes';
+import {getFunctionCallSignature} from '../Inference/InferMutationAliasingEffects';
 import {Result} from '../Utils/Result';
 
 /**
@@ -36,13 +36,20 @@ export function validateNoImpureFunctionsInRender(
         );
         if (signature != null && signature.impure === true) {
           errors.pushDiagnostic(
-            CompilerDiagnostic.fromCode(ErrorCode.IMPURE_FUNCTIONS).withDetail({
+            CompilerDiagnostic.create({
+              category: ErrorCategory.Purity,
+              reason: 'Cannot call impure function during render',
+              description:
+                (signature.canonicalName != null
+                  ? `\`${signature.canonicalName}\` is an impure function. `
+                  : '') +
+                'Calling an impure function can produce unstable results that update unpredictably when the component happens to re-render. (https://react.dev/reference/rules/components-and-hooks-must-be-pure#components-and-hooks-must-be-idempotent)',
+              severity: ErrorSeverity.InvalidReact,
+              suggestions: null,
+            }).withDetail({
               kind: 'error',
               loc: callee.loc,
-              message:
-                signature.canonicalName != null
-                  ? `\`${signature.canonicalName}\` is an impure function. `
-                  : 'This is an impure function.',
+              message: 'Cannot call impure function',
             }),
           );
         }

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

@@ -5,9 +5,9 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-import {CompilerDiagnostic, CompilerError} from '..';
+import {CompilerDiagnostic, CompilerError, ErrorSeverity} from '..';
+import {ErrorCategory} from '../CompilerError';
 import {BlockId, HIRFunction} from '../HIR';
-import {ErrorCode} from '../Utils/CompilerErrorCodes';
 import {Result} from '../Utils/Result';
 import {retainWhere} from '../Utils/utils';
 
@@ -36,7 +36,12 @@ export function validateNoJSXInTryStatement(
           case 'JsxExpression':
           case 'JsxFragment': {
             errors.pushDiagnostic(
-              CompilerDiagnostic.fromCode(ErrorCode.JSX_IN_TRY).withDetail({
+              CompilerDiagnostic.create({
+                category: ErrorCategory.ErrorBoundaries,
+                severity: ErrorSeverity.InvalidReact,
+                reason: 'Avoid constructing JSX within try/catch',
+                description: `React does not immediately render components when JSX is rendered, so any errors from this component will not be caught by the try/catch. To catch errors in rendering a given component, wrap that component in an error boundary. (https://react.dev/reference/react/Component#catching-rendering-errors-with-an-error-boundary)`,
+              }).withDetail({
                 kind: 'error',
                 loc: value.loc,
                 message: 'Avoid constructing JSX within try/catch',

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

@@ -5,7 +5,12 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-import {CompilerDiagnostic, CompilerError} from '../CompilerError';
+import {
+  CompilerDiagnostic,
+  CompilerError,
+  ErrorCategory,
+  ErrorSeverity,
+} from '../CompilerError';
 import {
   BlockId,
   HIRFunction,
@@ -22,7 +27,6 @@ import {
   eachPatternOperand,
   eachTerminalOperand,
 } from '../HIR/visitors';
-import {ErrorCode} from '../Utils/CompilerErrorCodes';
 import {Err, Ok, Result} from '../Utils/Result';
 import {retainWhere} from '../Utils/utils';
 
@@ -464,9 +468,12 @@ function validateNoRefAccessInRenderImpl(
               if (fnType.fn.readRefEffect) {
                 didError = true;
                 errors.pushDiagnostic(
-                  CompilerDiagnostic.fromCode(
-                    ErrorCode.NO_REF_ACCESS_IN_RENDER,
-                  ).withDetail({
+                  CompilerDiagnostic.create({
+                    category: ErrorCategory.Refs,
+                    severity: ErrorSeverity.InvalidReact,
+                    reason: 'Cannot access refs during render',
+                    description: ERROR_DESCRIPTION,
+                  }).withDetail({
                     kind: 'error',
                     loc: callee.loc,
                     message: `This function accesses a ref value`,
@@ -725,13 +732,16 @@ function destructure(
 function guardCheck(errors: CompilerError, operand: Place, env: Env): void {
   if (env.get(operand.identifier.id)?.kind === 'Guard') {
     errors.pushDiagnostic(
-      CompilerDiagnostic.fromCode(ErrorCode.NO_REF_ACCESS_IN_RENDER).withDetail(
-        {
-          kind: 'error',
-          loc: operand.loc,
-          message: `Cannot access ref value during render`,
-        },
-      ),
+      CompilerDiagnostic.create({
+        category: ErrorCategory.Refs,
+        severity: ErrorSeverity.InvalidReact,
+        reason: 'Cannot access refs during render',
+        description: ERROR_DESCRIPTION,
+      }).withDetail({
+        kind: 'error',
+        loc: operand.loc,
+        message: `Cannot access ref value during render`,
+      }),
     );
   }
 }
@@ -747,13 +757,16 @@ function validateNoRefValueAccess(
     (type?.kind === 'Structure' && type.fn?.readRefEffect)
   ) {
     errors.pushDiagnostic(
-      CompilerDiagnostic.fromCode(ErrorCode.NO_REF_ACCESS_IN_RENDER).withDetail(
-        {
-          kind: 'error',
-          loc: (type.kind === 'RefValue' && type.loc) || operand.loc,
-          message: `Cannot access ref value during render`,
-        },
-      ),
+      CompilerDiagnostic.create({
+        category: ErrorCategory.Refs,
+        severity: ErrorSeverity.InvalidReact,
+        reason: '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`,
+      }),
     );
   }
 }
@@ -771,13 +784,16 @@ function validateNoRefPassedToFunction(
     (type?.kind === 'Structure' && type.fn?.readRefEffect)
   ) {
     errors.pushDiagnostic(
-      CompilerDiagnostic.fromCode(ErrorCode.NO_REF_ACCESS_IN_RENDER).withDetail(
-        {
-          kind: 'error',
-          loc: (type.kind === 'RefValue' && type.loc) || loc,
-          message: `Passing a ref to a function may read its value during render`,
-        },
-      ),
+      CompilerDiagnostic.create({
+        category: ErrorCategory.Refs,
+        severity: ErrorSeverity.InvalidReact,
+        reason: '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`,
+      }),
     );
   }
 }
@@ -791,13 +807,16 @@ function validateNoRefUpdate(
   const type = destructure(env.get(operand.identifier.id));
   if (type?.kind === 'Ref' || type?.kind === 'RefValue') {
     errors.pushDiagnostic(
-      CompilerDiagnostic.fromCode(ErrorCode.NO_REF_ACCESS_IN_RENDER).withDetail(
-        {
-          kind: 'error',
-          loc: (type.kind === 'RefValue' && type.loc) || loc,
-          message: `Cannot update ref during render`,
-        },
-      ),
+      CompilerDiagnostic.create({
+        category: ErrorCategory.Refs,
+        severity: ErrorSeverity.InvalidReact,
+        reason: 'Cannot access refs during render',
+        description: ERROR_DESCRIPTION,
+      }).withDetail({
+        kind: 'error',
+        loc: (type.kind === 'RefValue' && type.loc) || loc,
+        message: `Cannot update ref during render`,
+      }),
     );
   }
 }
@@ -810,13 +829,22 @@ function validateNoDirectRefValueAccess(
   const type = destructure(env.get(operand.identifier.id));
   if (type?.kind === 'RefValue') {
     errors.pushDiagnostic(
-      CompilerDiagnostic.fromCode(ErrorCode.NO_REF_ACCESS_IN_RENDER).withDetail(
-        {
-          kind: 'error',
-          loc: type.loc ?? operand.loc,
-          message: `Cannot access ref value during render`,
-        },
-      ),
+      CompilerDiagnostic.create({
+        category: ErrorCategory.Refs,
+        severity: ErrorSeverity.InvalidReact,
+        reason: 'Cannot access refs during render',
+        description: ERROR_DESCRIPTION,
+      }).withDetail({
+        kind: 'error',
+        loc: type.loc ?? operand.loc,
+        message: `Cannot access ref value during render`,
+      }),
     );
   }
 }
+
+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

@@ -5,7 +5,12 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-import {CompilerDiagnostic, CompilerError} from '../CompilerError';
+import {
+  CompilerDiagnostic,
+  CompilerError,
+  ErrorCategory,
+  ErrorSeverity,
+} from '../CompilerError';
 import {
   HIRFunction,
   IdentifierId,
@@ -16,7 +21,6 @@ import {
   Place,
 } from '../HIR';
 import {eachInstructionValueOperand} from '../HIR/visitors';
-import {ErrorCode} from '../Utils/CompilerErrorCodes';
 import {Result} from '../Utils/Result';
 
 /**
@@ -92,9 +96,20 @@ export function validateNoSetStateInEffects(
               const setState = setStateFunctions.get(arg.identifier.id);
               if (setState !== undefined) {
                 errors.pushDiagnostic(
-                  CompilerDiagnostic.fromCode(
-                    ErrorCode.INVALID_SET_STATE_IN_EFFECTS,
-                  ).withDetail({
+                  CompilerDiagnostic.create({
+                    category: ErrorCategory.EffectSetState,
+                    reason:
+                      '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\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)',
+                    severity: ErrorSeverity.InvalidReact,
+                    suggestions: null,
+                  }).withDetail({
                     kind: 'error',
                     loc: setState.loc,
                     message:

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

@@ -5,11 +5,15 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-import {CompilerDiagnostic, CompilerError} from '../CompilerError';
+import {
+  CompilerDiagnostic,
+  CompilerError,
+  ErrorCategory,
+  ErrorSeverity,
+} from '../CompilerError';
 import {HIRFunction, IdentifierId, isSetStateType} from '../HIR';
 import {computeUnconditionalBlocks} from '../HIR/ComputeUnconditionalBlocks';
 import {eachInstructionValueOperand} from '../HIR/visitors';
-import {ErrorCode} from '../Utils/CompilerErrorCodes';
 import {Result} from '../Utils/Result';
 
 /**
@@ -124,9 +128,15 @@ function validateNoSetStateInRenderImpl(
           ) {
             if (activeManualMemoId !== null) {
               errors.pushDiagnostic(
-                CompilerDiagnostic.fromCode(
-                  ErrorCode.INVALID_SET_STATE_IN_MEMO,
-                ).withDetail({
+                CompilerDiagnostic.create({
+                  category: ErrorCategory.RenderSetState,
+                  reason:
+                    'Calling setState from useMemo may trigger an infinite loop',
+                  description:
+                    'Each time the memo callback is evaluated it will change state. This can cause a memoization dependency to change, running the memo function again and causing an infinite loop. Instead of setting state in useMemo(), prefer deriving the value during render. (https://react.dev/reference/react/useState)',
+                  severity: ErrorSeverity.InvalidReact,
+                  suggestions: null,
+                }).withDetail({
                   kind: 'error',
                   loc: callee.loc,
                   message: 'Found setState() within useMemo()',
@@ -134,12 +144,18 @@ function validateNoSetStateInRenderImpl(
               );
             } else if (unconditionalBlocks.has(block.id)) {
               errors.pushDiagnostic(
-                CompilerDiagnostic.fromCode(
-                  ErrorCode.INVALID_SET_STATE_IN_RENDER,
-                ).withDetail({
+                CompilerDiagnostic.create({
+                  category: ErrorCategory.RenderSetState,
+                  reason:
+                    'Calling setState during render may trigger an infinite loop',
+                  description:
+                    'Calling setState during render will trigger another render, and can lead to infinite loops. (https://react.dev/reference/react/useState)',
+                  severity: ErrorSeverity.InvalidReact,
+                  suggestions: null,
+                }).withDetail({
                   kind: 'error',
                   loc: callee.loc,
-                  message: 'Found setState() during render',
+                  message: 'Found setState() in render',
                 }),
               );
             }

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

@@ -5,7 +5,12 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-import {CompilerDiagnostic, CompilerError, ErrorCode} from '../CompilerError';
+import {
+  CompilerDiagnostic,
+  CompilerError,
+  ErrorCategory,
+  ErrorSeverity,
+} from '../CompilerError';
 import {
   DeclarationId,
   Effect,
@@ -276,8 +281,14 @@ function validateInferredDep(
     }
   }
   errorState.pushDiagnostic(
-    CompilerDiagnostic.fromCode(ErrorCode.MANUAL_MEMO_DEPENDENCIES_CONFLICT, {
-      description:
+    CompilerDiagnostic.create({
+      category: ErrorCategory.PreserveManualMemo,
+      severity: ErrorSeverity.CannotPreserveMemoization,
+      reason:
+        'Compilation skipped because existing memoization could not be preserved',
+      description: [
+        'React Compiler has skipped optimizing this component because the existing manual memoization could not be preserved. ',
+        'The inferred dependencies did not match the manually specified dependencies, which could cause the value to change more or less frequently than expected. ',
         DEBUG ||
         // If the dependency is a named variable then we can report it. Otherwise only print in debug mode
         (dep.identifier.name != null && dep.identifier.name.kind === 'named')
@@ -289,8 +300,11 @@ function validateInferredDep(
               errorDiagnostic
                 ? getCompareDependencyResultDescription(errorDiagnostic)
                 : 'Inferred dependency not present in source'
-            }`
+            }.`
           : '',
+      ]
+        .join('')
+        .trim(),
       suggestions: null,
     }).withDetail({
       kind: 'error',
@@ -522,9 +536,16 @@ class Visitor extends ReactiveFunctionVisitor<VisitorState> {
           !this.prunedScopes.has(identifier.scope.id)
         ) {
           state.errors.pushDiagnostic(
-            CompilerDiagnostic.fromCode(
-              ErrorCode.MANUAL_MEMO_MUTATED_LATER,
-            ).withDetail({
+            CompilerDiagnostic.create({
+              category: ErrorCategory.PreserveManualMemo,
+              severity: ErrorSeverity.CannotPreserveMemoization,
+              reason:
+                'Compilation skipped because existing memoization could not be preserved',
+              description: [
+                'React Compiler has skipped optimizing this component because the existing manual memoization could not be preserved. ',
+                'This dependency may be mutated later, which could cause the value to change unexpectedly.',
+              ].join(''),
+            }).withDetail({
               kind: 'error',
               loc,
               message: 'This dependency may be modified later',
@@ -564,10 +585,19 @@ class Visitor extends ReactiveFunctionVisitor<VisitorState> {
           for (const identifier of decls) {
             if (isUnmemoized(identifier, this.scopes)) {
               state.errors.pushDiagnostic(
-                CompilerDiagnostic.fromCode(ErrorCode.MANUAL_MEMO_REMOVED, {
-                  description: DEBUG
-                    ? `${printIdentifier(identifier)} was not memoized`
-                    : '',
+                CompilerDiagnostic.create({
+                  category: ErrorCategory.PreserveManualMemo,
+                  severity: ErrorSeverity.CannotPreserveMemoization,
+                  reason:
+                    'Compilation skipped because existing memoization could not be preserved',
+                  description: [
+                    'React Compiler has skipped optimizing this component because the existing manual memoization could not be preserved. This value was memoized in source but not in compilation output. ',
+                    DEBUG
+                      ? `${printIdentifier(identifier)} was not memoized.`
+                      : '',
+                  ]
+                    .join('')
+                    .trim(),
                 }).withDetail({
                   kind: 'error',
                   loc,

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

@@ -5,9 +5,13 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-import {CompilerDiagnostic, CompilerError} from '../CompilerError';
+import {
+  CompilerDiagnostic,
+  CompilerError,
+  ErrorCategory,
+  ErrorSeverity,
+} from '../CompilerError';
 import {HIRFunction, IdentifierId, SourceLocation} from '../HIR';
-import {ErrorCode} from '../Utils/CompilerErrorCodes';
 import {Result} from '../Utils/Result';
 
 /**
@@ -61,7 +65,10 @@ export function validateStaticComponents(
             );
             if (location != null) {
               error.pushDiagnostic(
-                CompilerDiagnostic.fromCode(ErrorCode.STATIC_COMPONENTS, {
+                CompilerDiagnostic.create({
+                  category: ErrorCategory.StaticComponents,
+                  severity: ErrorSeverity.InvalidReact,
+                  reason: 'Cannot create components during render',
                   description: `Components created during render will reset their state each time they are created. Declare components outside of render. `,
                 })
                   .withDetail({

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

@@ -5,9 +5,13 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-import {CompilerDiagnostic, CompilerError} from '../CompilerError';
+import {
+  CompilerDiagnostic,
+  CompilerError,
+  ErrorCategory,
+  ErrorSeverity,
+} from '../CompilerError';
 import {FunctionExpression, HIRFunction, IdentifierId} from '../HIR';
-import {ErrorCode} from '../Utils/CompilerErrorCodes';
 import {Result} from '../Utils/Result';
 
 export function validateUseMemo(fn: HIRFunction): Result<void, CompilerError> {
@@ -70,9 +74,14 @@ export function validateUseMemo(fn: HIRFunction): Result<void, CompilerError> {
                 ? firstParam.loc
                 : firstParam.place.loc;
             errors.pushDiagnostic(
-              CompilerDiagnostic.fromCode(
-                ErrorCode.INVALID_USE_MEMO_CALLBACK_PARAMETERS,
-              ).withDetail({
+              CompilerDiagnostic.create({
+                category: ErrorCategory.UseMemo,
+                severity: ErrorSeverity.InvalidReact,
+                reason: 'useMemo() callbacks may not accept parameters',
+                description:
+                  'useMemo() callbacks are called by React to cache calculations across re-renders. They should not take parameters. Instead, directly reference the props, state, or local variables needed for the computation.',
+                suggestions: null,
+              }).withDetail({
                 kind: 'error',
                 loc,
                 message: 'Callbacks with parameters are not supported',
@@ -82,9 +91,15 @@ export function validateUseMemo(fn: HIRFunction): Result<void, CompilerError> {
 
           if (body.loweredFunc.func.async || body.loweredFunc.func.generator) {
             errors.pushDiagnostic(
-              CompilerDiagnostic.fromCode(
-                ErrorCode.INVALID_USE_MEMO_CALLBACK_ASYNC,
-              ).withDetail({
+              CompilerDiagnostic.create({
+                category: ErrorCategory.UseMemo,
+                severity: ErrorSeverity.InvalidReact,
+                reason:
+                  'useMemo() callbacks may not be async or generator functions',
+                description:
+                  'useMemo() callbacks are called once and must synchronously return a value.',
+                suggestions: null,
+              }).withDetail({
                 kind: 'error',
                 loc: body.loc,
                 message: 'Async and generator functions are not supported',

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/allow-assigning-to-global-in-function-spread-as-jsx.expect.md

@@ -0,0 +1,39 @@
+
+## Input
+
+```javascript
+// @enableNewMutationAliasingModel:false
+function Component() {
+  const foo = () => {
+    someGlobal = true;
+  };
+  // spreading a function is weird, but it doesn't call the function so this is allowed
+  return <div {...foo} />;
+}
+
+```
+
+## Code
+
+```javascript
+import { c as _c } from "react/compiler-runtime"; // @enableNewMutationAliasingModel:false
+function Component() {
+  const $ = _c(1);
+  const foo = _temp;
+  let t0;
+  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+    t0 = <div {...foo} />;
+    $[0] = t0;
+  } else {
+    t0 = $[0];
+  }
+  return t0;
+}
+function _temp() {
+  someGlobal = true;
+}
+
+```
+      
+### Eval output
+(kind: exception) Fixture not implemented

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/allow-assigning-to-global-in-function-spread-as-jsx.js

@@ -3,5 +3,6 @@ function Component() {
   const foo = () => {
     someGlobal = true;
   };
+  // spreading a function is weird, but it doesn't call the function so this is allowed
   return <div {...foo} />;
 }

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/bug-aliased-capture-aliased-mutate.expect.md

@@ -1,107 +0,0 @@
-
-## Input
-
-```javascript
-// @flow @enableTransitivelyFreezeFunctionExpressions:false @enableNewMutationAliasingModel:false
-import {arrayPush, setPropertyByKey, Stringify} from 'shared-runtime';
-
-/**
- * 1. `InferMutableRanges` derives the mutable range of identifiers and their
- *     aliases from `LoadLocal`, `PropertyLoad`, etc
- *   - After this pass, y's mutable range only extends to `arrayPush(x, y)`
- *   - We avoid assigning mutable ranges to loads after y's mutable range, as
- *     these are working with an immutable value. As a result, `LoadLocal y` and
- *     `PropertyLoad y` do not get mutable ranges
- * 2. `InferReactiveScopeVariables` extends mutable ranges and creates scopes,
- *    as according to the 'co-mutation' of different values
- *   - Here, we infer that
- *     - `arrayPush(y, x)` might alias `x` and `y` to each other
- *     - `setPropertyKey(x, ...)` may mutate both `x` and `y`
- *   - This pass correctly extends the mutable range of `y`
- *   - Since we didn't run `InferMutableRange` logic again, the LoadLocal /
- *     PropertyLoads still don't have a mutable range
- *
- * Note that the this bug is an edge case. Compiler output is only invalid for:
- *  - function expressions with
- *    `enableTransitivelyFreezeFunctionExpressions:false`
- *  - functions that throw and get retried without clearing the memocache
- *
- * Found differences in evaluator results
- * Non-forget (expected):
- *   (kind: ok)
- *   <div>{"cb":{"kind":"Function","result":10},"shouldInvokeFns":true}</div>
- *   <div>{"cb":{"kind":"Function","result":11},"shouldInvokeFns":true}</div>
- * Forget:
- *   (kind: ok)
- *   <div>{"cb":{"kind":"Function","result":10},"shouldInvokeFns":true}</div>
- *   <div>{"cb":{"kind":"Function","result":10},"shouldInvokeFns":true}</div>
- */
-function useFoo({a, b}: {a: number, b: number}) {
-  const x = [];
-  const y = {value: a};
-
-  arrayPush(x, y); // x and y co-mutate
-  const y_alias = y;
-  const cb = () => y_alias.value;
-  setPropertyByKey(x[0], 'value', b); // might overwrite y.value
-  return <Stringify cb={cb} shouldInvokeFns={true} />;
-}
-
-export const FIXTURE_ENTRYPOINT = {
-  fn: useFoo,
-  params: [{a: 2, b: 10}],
-  sequentialRenders: [
-    {a: 2, b: 10},
-    {a: 2, b: 11},
-  ],
-};
-
-```
-
-## Code
-
-```javascript
-import { c as _c } from "react/compiler-runtime";
-import { arrayPush, setPropertyByKey, Stringify } from "shared-runtime";
-
-function useFoo(t0) {
-  const $ = _c(5);
-  const { a, b } = t0;
-  let t1;
-  if ($[0] !== a || $[1] !== b) {
-    const x = [];
-    const y = { value: a };
-
-    arrayPush(x, y);
-    const y_alias = y;
-    let t2;
-    if ($[3] !== y_alias.value) {
-      t2 = () => y_alias.value;
-      $[3] = y_alias.value;
-      $[4] = t2;
-    } else {
-      t2 = $[4];
-    }
-    const cb = t2;
-    setPropertyByKey(x[0], "value", b);
-    t1 = <Stringify cb={cb} shouldInvokeFns={true} />;
-    $[0] = a;
-    $[1] = b;
-    $[2] = t1;
-  } else {
-    t1 = $[2];
-  }
-  return t1;
-}
-
-export const FIXTURE_ENTRYPOINT = {
-  fn: useFoo,
-  params: [{ a: 2, b: 10 }],
-  sequentialRenders: [
-    { a: 2, b: 10 },
-    { a: 2, b: 11 },
-  ],
-};
-
-```
-      

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/bug-aliased-capture-aliased-mutate.js

@@ -1,53 +0,0 @@
-// @flow @enableTransitivelyFreezeFunctionExpressions:false @enableNewMutationAliasingModel:false
-import {arrayPush, setPropertyByKey, Stringify} from 'shared-runtime';
-
-/**
- * 1. `InferMutableRanges` derives the mutable range of identifiers and their
- *     aliases from `LoadLocal`, `PropertyLoad`, etc
- *   - After this pass, y's mutable range only extends to `arrayPush(x, y)`
- *   - We avoid assigning mutable ranges to loads after y's mutable range, as
- *     these are working with an immutable value. As a result, `LoadLocal y` and
- *     `PropertyLoad y` do not get mutable ranges
- * 2. `InferReactiveScopeVariables` extends mutable ranges and creates scopes,
- *    as according to the 'co-mutation' of different values
- *   - Here, we infer that
- *     - `arrayPush(y, x)` might alias `x` and `y` to each other
- *     - `setPropertyKey(x, ...)` may mutate both `x` and `y`
- *   - This pass correctly extends the mutable range of `y`
- *   - Since we didn't run `InferMutableRange` logic again, the LoadLocal /
- *     PropertyLoads still don't have a mutable range
- *
- * Note that the this bug is an edge case. Compiler output is only invalid for:
- *  - function expressions with
- *    `enableTransitivelyFreezeFunctionExpressions:false`
- *  - functions that throw and get retried without clearing the memocache
- *
- * Found differences in evaluator results
- * Non-forget (expected):
- *   (kind: ok)
- *   <div>{"cb":{"kind":"Function","result":10},"shouldInvokeFns":true}</div>
- *   <div>{"cb":{"kind":"Function","result":11},"shouldInvokeFns":true}</div>
- * Forget:
- *   (kind: ok)
- *   <div>{"cb":{"kind":"Function","result":10},"shouldInvokeFns":true}</div>
- *   <div>{"cb":{"kind":"Function","result":10},"shouldInvokeFns":true}</div>
- */
-function useFoo({a, b}: {a: number, b: number}) {
-  const x = [];
-  const y = {value: a};
-
-  arrayPush(x, y); // x and y co-mutate
-  const y_alias = y;
-  const cb = () => y_alias.value;
-  setPropertyByKey(x[0], 'value', b); // might overwrite y.value
-  return <Stringify cb={cb} shouldInvokeFns={true} />;
-}
-
-export const FIXTURE_ENTRYPOINT = {
-  fn: useFoo,
-  params: [{a: 2, b: 10}],
-  sequentialRenders: [
-    {a: 2, b: 10},
-    {a: 2, b: 11},
-  ],
-};

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/bug-aliased-capture-mutate.expect.md

@@ -1,87 +0,0 @@
-
-## Input
-
-```javascript
-// @flow @enableTransitivelyFreezeFunctionExpressions:false @enableNewMutationAliasingModel:false
-import {setPropertyByKey, Stringify} from 'shared-runtime';
-
-/**
- * Variation of bug in `bug-aliased-capture-aliased-mutate`
- * Found differences in evaluator results
- * Non-forget (expected):
- *   (kind: ok)
- *   <div>{"cb":{"kind":"Function","result":2},"shouldInvokeFns":true}</div>
- *   <div>{"cb":{"kind":"Function","result":3},"shouldInvokeFns":true}</div>
- * Forget:
- *   (kind: ok)
- *   <div>{"cb":{"kind":"Function","result":2},"shouldInvokeFns":true}</div>
- *   <div>{"cb":{"kind":"Function","result":2},"shouldInvokeFns":true}</div>
- */
-
-function useFoo({a}: {a: number, b: number}) {
-  const arr = [];
-  const obj = {value: a};
-
-  setPropertyByKey(obj, 'arr', arr);
-  const obj_alias = obj;
-  const cb = () => obj_alias.arr.length;
-  for (let i = 0; i < a; i++) {
-    arr.push(i);
-  }
-  return <Stringify cb={cb} shouldInvokeFns={true} />;
-}
-
-export const FIXTURE_ENTRYPOINT = {
-  fn: useFoo,
-  params: [{a: 2}],
-  sequentialRenders: [{a: 2}, {a: 3}],
-};
-
-```
-
-## Code
-
-```javascript
-import { c as _c } from "react/compiler-runtime";
-import { setPropertyByKey, Stringify } from "shared-runtime";
-
-function useFoo(t0) {
-  const $ = _c(4);
-  const { a } = t0;
-  let t1;
-  if ($[0] !== a) {
-    const arr = [];
-    const obj = { value: a };
-
-    setPropertyByKey(obj, "arr", arr);
-    const obj_alias = obj;
-    let t2;
-    if ($[2] !== obj_alias.arr.length) {
-      t2 = () => obj_alias.arr.length;
-      $[2] = obj_alias.arr.length;
-      $[3] = t2;
-    } else {
-      t2 = $[3];
-    }
-    const cb = t2;
-    for (let i = 0; i < a; i++) {
-      arr.push(i);
-    }
-
-    t1 = <Stringify cb={cb} shouldInvokeFns={true} />;
-    $[0] = a;
-    $[1] = t1;
-  } else {
-    t1 = $[1];
-  }
-  return t1;
-}
-
-export const FIXTURE_ENTRYPOINT = {
-  fn: useFoo,
-  params: [{ a: 2 }],
-  sequentialRenders: [{ a: 2 }, { a: 3 }],
-};
-
-```
-      

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/bug-aliased-capture-mutate.js

@@ -1,34 +0,0 @@
-// @flow @enableTransitivelyFreezeFunctionExpressions:false @enableNewMutationAliasingModel:false
-import {setPropertyByKey, Stringify} from 'shared-runtime';
-
-/**
- * Variation of bug in `bug-aliased-capture-aliased-mutate`
- * Found differences in evaluator results
- * Non-forget (expected):
- *   (kind: ok)
- *   <div>{"cb":{"kind":"Function","result":2},"shouldInvokeFns":true}</div>
- *   <div>{"cb":{"kind":"Function","result":3},"shouldInvokeFns":true}</div>
- * Forget:
- *   (kind: ok)
- *   <div>{"cb":{"kind":"Function","result":2},"shouldInvokeFns":true}</div>
- *   <div>{"cb":{"kind":"Function","result":2},"shouldInvokeFns":true}</div>
- */
-
-function useFoo({a}: {a: number, b: number}) {
-  const arr = [];
-  const obj = {value: a};
-
-  setPropertyByKey(obj, 'arr', arr);
-  const obj_alias = obj;
-  const cb = () => obj_alias.arr.length;
-  for (let i = 0; i < a; i++) {
-    arr.push(i);
-  }
-  return <Stringify cb={cb} shouldInvokeFns={true} />;
-}
-
-export const FIXTURE_ENTRYPOINT = {
-  fn: useFoo,
-  params: [{a: 2}],
-  sequentialRenders: [{a: 2}, {a: 3}],
-};

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/bug-capturing-func-maybealias-captured-mutate.expect.md

@@ -85,19 +85,11 @@ import { makeArray, mutate } from "shared-runtime";
  * used when we analyze CallExpressions.
  */
 function Component(t0) {
-  const $ = _c(5);
+  const $ = _c(3);
   const { foo, bar } = t0;
-  let t1;
-  if ($[0] !== foo) {
-    t1 = { foo };
-    $[0] = foo;
-    $[1] = t1;
-  } else {
-    t1 = $[1];
-  }
-  const x = t1;
   let y;
-  if ($[2] !== bar || $[3] !== x) {
+  if ($[0] !== bar || $[1] !== foo) {
+    const x = { foo };
     y = { bar };
     const f0 = function () {
       const a = makeArray(y);
@@ -108,11 +100,11 @@ function Component(t0) {
 
     f0();
     mutate(y.x);
-    $[2] = bar;
-    $[3] = x;
-    $[4] = y;
+    $[0] = bar;
+    $[1] = foo;
+    $[2] = y;
   } else {
-    y = $[4];
+    y = $[2];
   }
   return y;
 }

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/bug-invalid-phi-as-dependency.expect.md

@@ -1,92 +0,0 @@
-
-## Input
-
-```javascript
-// @enableNewMutationAliasingModel:false
-import {CONST_TRUE, Stringify, mutate, useIdentity} from 'shared-runtime';
-
-/**
- * Fixture showing an edge case for ReactiveScope variable propagation.
- *
- * Found differences in evaluator results
- *   Non-forget (expected):
- *   <div>{"obj":{"inner":{"value":"hello"},"wat0":"joe"},"inner":["[[ cyclic ref *2 ]]"]}</div>
- *   <div>{"obj":{"inner":{"value":"hello"},"wat0":"joe"},"inner":["[[ cyclic ref *2 ]]"]}</div>
- *   Forget:
- *   <div>{"obj":{"inner":{"value":"hello"},"wat0":"joe"},"inner":["[[ cyclic ref *2 ]]"]}</div>
- *   [[ (exception in render) Error: invariant broken ]]
- *
- */
-function Component() {
-  const obj = CONST_TRUE ? {inner: {value: 'hello'}} : null;
-  const boxedInner = [obj?.inner];
-  useIdentity(null);
-  mutate(obj);
-  if (boxedInner[0] !== obj?.inner) {
-    throw new Error('invariant broken');
-  }
-  return <Stringify obj={obj} inner={boxedInner} />;
-}
-
-export const FIXTURE_ENTRYPOINT = {
-  fn: Component,
-  params: [{arg: 0}],
-  sequentialRenders: [{arg: 0}, {arg: 1}],
-};
-
-```
-
-## Code
-
-```javascript
-import { c as _c } from "react/compiler-runtime"; // @enableNewMutationAliasingModel:false
-import { CONST_TRUE, Stringify, mutate, useIdentity } from "shared-runtime";
-
-/**
- * Fixture showing an edge case for ReactiveScope variable propagation.
- *
- * Found differences in evaluator results
- *   Non-forget (expected):
- *   <div>{"obj":{"inner":{"value":"hello"},"wat0":"joe"},"inner":["[[ cyclic ref *2 ]]"]}</div>
- *   <div>{"obj":{"inner":{"value":"hello"},"wat0":"joe"},"inner":["[[ cyclic ref *2 ]]"]}</div>
- *   Forget:
- *   <div>{"obj":{"inner":{"value":"hello"},"wat0":"joe"},"inner":["[[ cyclic ref *2 ]]"]}</div>
- *   [[ (exception in render) Error: invariant broken ]]
- *
- */
-function Component() {
-  const $ = _c(4);
-  const obj = CONST_TRUE ? { inner: { value: "hello" } } : null;
-  let t0;
-  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
-    t0 = [obj?.inner];
-    $[0] = t0;
-  } else {
-    t0 = $[0];
-  }
-  const boxedInner = t0;
-  useIdentity(null);
-  mutate(obj);
-  if (boxedInner[0] !== obj?.inner) {
-    throw new Error("invariant broken");
-  }
-  let t1;
-  if ($[1] !== boxedInner || $[2] !== obj) {
-    t1 = <Stringify obj={obj} inner={boxedInner} />;
-    $[1] = boxedInner;
-    $[2] = obj;
-    $[3] = t1;
-  } else {
-    t1 = $[3];
-  }
-  return t1;
-}
-
-export const FIXTURE_ENTRYPOINT = {
-  fn: Component,
-  params: [{ arg: 0 }],
-  sequentialRenders: [{ arg: 0 }, { arg: 1 }],
-};
-
-```
-      

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/bug-invalid-phi-as-dependency.tsx

@@ -1,31 +0,0 @@
-// @enableNewMutationAliasingModel:false
-import {CONST_TRUE, Stringify, mutate, useIdentity} from 'shared-runtime';
-
-/**
- * Fixture showing an edge case for ReactiveScope variable propagation.
- *
- * Found differences in evaluator results
- *   Non-forget (expected):
- *   <div>{"obj":{"inner":{"value":"hello"},"wat0":"joe"},"inner":["[[ cyclic ref *2 ]]"]}</div>
- *   <div>{"obj":{"inner":{"value":"hello"},"wat0":"joe"},"inner":["[[ cyclic ref *2 ]]"]}</div>
- *   Forget:
- *   <div>{"obj":{"inner":{"value":"hello"},"wat0":"joe"},"inner":["[[ cyclic ref *2 ]]"]}</div>
- *   [[ (exception in render) Error: invariant broken ]]
- *
- */
-function Component() {
-  const obj = CONST_TRUE ? {inner: {value: 'hello'}} : null;
-  const boxedInner = [obj?.inner];
-  useIdentity(null);
-  mutate(obj);
-  if (boxedInner[0] !== obj?.inner) {
-    throw new Error('invariant broken');
-  }
-  return <Stringify obj={obj} inner={boxedInner} />;
-}
-
-export const FIXTURE_ENTRYPOINT = {
-  fn: Component,
-  params: [{arg: 0}],
-  sequentialRenders: [{arg: 0}, {arg: 1}],
-};

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/bug-object-expression-computed-key-modified-during-after-construction-hoisted-sequence-expr.expect.md

@@ -1,110 +0,0 @@
-
-## Input
-
-```javascript
-// @enableNewMutationAliasingModel:false
-import {identity, mutate} from 'shared-runtime';
-
-/**
- * Bug: copy of error.todo-object-expression-computed-key-modified-during-after-construction-sequence-expr
- * with the mutation hoisted to a named variable instead of being directly
- * inlined into the Object key.
- *
- * Found differences in evaluator results
- *   Non-forget (expected):
- *   (kind: ok) [{"[object Object]":[42]},{"wat0":"joe","wat1":"joe"}]
- *   [{"[object Object]":[42]},{"wat0":"joe","wat1":"joe"}]
- *   Forget:
- *   (kind: ok) [{"[object Object]":[42]},{"wat0":"joe","wat1":"joe"}]
- *   [{"[object Object]":[42]},{"wat0":"joe","wat1":"joe","wat2":"joe"}]
- */
-function Component(props) {
-  const key = {};
-  const tmp = (mutate(key), key);
-  const context = {
-    // Here, `tmp` is frozen (as it's inferred to be a primitive/string)
-    [tmp]: identity([props.value]),
-  };
-  mutate(key);
-  return [context, key];
-}
-
-export const FIXTURE_ENTRYPOINT = {
-  fn: Component,
-  params: [{value: 42}],
-  sequentialRenders: [{value: 42}, {value: 42}],
-};
-
-```
-
-## Code
-
-```javascript
-import { c as _c } from "react/compiler-runtime"; // @enableNewMutationAliasingModel:false
-import { identity, mutate } from "shared-runtime";
-
-/**
- * Bug: copy of error.todo-object-expression-computed-key-modified-during-after-construction-sequence-expr
- * with the mutation hoisted to a named variable instead of being directly
- * inlined into the Object key.
- *
- * Found differences in evaluator results
- *   Non-forget (expected):
- *   (kind: ok) [{"[object Object]":[42]},{"wat0":"joe","wat1":"joe"}]
- *   [{"[object Object]":[42]},{"wat0":"joe","wat1":"joe"}]
- *   Forget:
- *   (kind: ok) [{"[object Object]":[42]},{"wat0":"joe","wat1":"joe"}]
- *   [{"[object Object]":[42]},{"wat0":"joe","wat1":"joe","wat2":"joe"}]
- */
-function Component(props) {
-  const $ = _c(8);
-  let key;
-  let t0;
-  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
-    key = {};
-    t0 = (mutate(key), key);
-    $[0] = key;
-    $[1] = t0;
-  } else {
-    key = $[0];
-    t0 = $[1];
-  }
-  const tmp = t0;
-  let t1;
-  if ($[2] !== props.value) {
-    t1 = identity([props.value]);
-    $[2] = props.value;
-    $[3] = t1;
-  } else {
-    t1 = $[3];
-  }
-  let t2;
-  if ($[4] !== t1) {
-    t2 = { [tmp]: t1 };
-    $[4] = t1;
-    $[5] = t2;
-  } else {
-    t2 = $[5];
-  }
-  const context = t2;
-
-  mutate(key);
-  let t3;
-  if ($[6] !== context) {
-    t3 = [context, key];
-    $[6] = context;
-    $[7] = t3;
-  } else {
-    t3 = $[7];
-  }
-  return t3;
-}
-
-export const FIXTURE_ENTRYPOINT = {
-  fn: Component,
-  params: [{ value: 42 }],
-  sequentialRenders: [{ value: 42 }, { value: 42 }],
-};
-
-```
-      

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/bug-object-expression-computed-key-modified-during-after-construction-hoisted-sequence-expr.js

@@ -1,32 +0,0 @@
-// @enableNewMutationAliasingModel:false
-import {identity, mutate} from 'shared-runtime';
-
-/**
- * Bug: copy of error.todo-object-expression-computed-key-modified-during-after-construction-sequence-expr
- * with the mutation hoisted to a named variable instead of being directly
- * inlined into the Object key.
- *
- * Found differences in evaluator results
- *   Non-forget (expected):
- *   (kind: ok) [{"[object Object]":[42]},{"wat0":"joe","wat1":"joe"}]
- *   [{"[object Object]":[42]},{"wat0":"joe","wat1":"joe"}]
- *   Forget:
- *   (kind: ok) [{"[object Object]":[42]},{"wat0":"joe","wat1":"joe"}]
- *   [{"[object Object]":[42]},{"wat0":"joe","wat1":"joe","wat2":"joe"}]
- */
-function Component(props) {
-  const key = {};
-  const tmp = (mutate(key), key);
-  const context = {
-    // Here, `tmp` is frozen (as it's inferred to be a primitive/string)
-    [tmp]: identity([props.value]),
-  };
-  mutate(key);
-  return [context, key];
-}
-
-export const FIXTURE_ENTRYPOINT = {
-  fn: Component,
-  params: [{value: 42}],
-  sequentialRenders: [{value: 42}, {value: 42}],
-};

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.assign-global-in-component-tag-function.expect.md

@@ -19,13 +19,13 @@ Found 1 error:
 
 Error: Cannot reassign variables declared outside of the component/hook
 
-Reassigning this value during render is a form of side effect, which can cause unpredictable behavior depending on when the component happens to re-render. If this variable is used in rendering, use useState instead. Otherwise, consider updating it in an effect. (https://react.dev/reference/rules/components-and-hooks-must-be-pure#side-effects-must-run-outside-of-render).
+Variable `someGlobal` is declared outside of the component/hook. Reassigning this value during render is a form of side effect, which can cause unpredictable behavior depending on when the component happens to re-render. If this variable is used in rendering, use useState instead. Otherwise, consider updating it in an effect. (https://react.dev/reference/rules/components-and-hooks-must-be-pure#side-effects-must-run-outside-of-render)
 
 error.assign-global-in-component-tag-function.ts:3:4
   1 | function Component() {
   2 |   const Foo = () => {
 > 3 |     someGlobal = true;
-    |     ^^^^^^^^^^ `someGlobal` should not be reassigned
+    |     ^^^^^^^^^^ `someGlobal` cannot be reassigned
   4 |   };
   5 |   return <Foo />;
   6 | }

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.assign-global-in-jsx-children.expect.md

@@ -22,13 +22,13 @@ Found 1 error:
 
 Error: Cannot reassign variables declared outside of the component/hook
 
-Reassigning this value during render is a form of side effect, which can cause unpredictable behavior depending on when the component happens to re-render. If this variable is used in rendering, use useState instead. Otherwise, consider updating it in an effect. (https://react.dev/reference/rules/components-and-hooks-must-be-pure#side-effects-must-run-outside-of-render).
+Variable `someGlobal` is declared outside of the component/hook. Reassigning this value during render is a form of side effect, which can cause unpredictable behavior depending on when the component happens to re-render. If this variable is used in rendering, use useState instead. Otherwise, consider updating it in an effect. (https://react.dev/reference/rules/components-and-hooks-must-be-pure#side-effects-must-run-outside-of-render)
 
 error.assign-global-in-jsx-children.ts:3:4
   1 | function Component() {
   2 |   const foo = () => {
 > 3 |     someGlobal = true;
-    |     ^^^^^^^^^^ `someGlobal` should not be reassigned
+    |     ^^^^^^^^^^ `someGlobal` cannot be reassigned
   4 |   };
   5 |   // Children are generally access/called during render, so
   6 |   // modifying a global in a children function is almost

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.assign-global-in-jsx-spread-attribute.expect.md

@@ -1,35 +0,0 @@
-
-## Input
-
-```javascript
-// @enableNewMutationAliasingModel:false
-function Component() {
-  const foo = () => {
-    someGlobal = true;
-  };
-  return <div {...foo} />;
-}
-
-```
-
-
-## Error
-
-```
-Found 1 error:
-
-Error: Cannot reassign variables declared outside of the component/hook
-
-Reassigning this value during render is a form of side effect, which can cause unpredictable behavior depending on when the component happens to re-render. If this variable is used in rendering, use useState instead. Otherwise, consider updating it in an effect. (https://react.dev/reference/rules/components-and-hooks-must-be-pure#side-effects-must-run-outside-of-render).
-
-error.assign-global-in-jsx-spread-attribute.ts:4:4
-  2 | function Component() {
-  3 |   const foo = () => {
-> 4 |     someGlobal = true;
-    |     ^^^^^^^^^^ Cannot reassign variables declared outside of the component/hook
-  5 |   };
-  6 |   return <div {...foo} />;
-  7 | }
-```
-          
-      

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

@@ -20,7 +20,7 @@ Found 1 error:
 
 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. Found suppression `$FlowFixMe[react-rule-hook]`.
+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]`
 
 error.bailout-on-flow-suppression.ts:4:2
   2 |

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

@@ -23,7 +23,7 @@ Found 2 errors:
 
 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. Found suppression `eslint-disable my-app/react-rule`.
+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`
 
 error.bailout-on-suppression-of-custom-rule.ts:3:0
   1 | // @eslintSuppressionRules:["my-app","react-rule"]
@@ -36,7 +36,7 @@ error.bailout-on-suppression-of-custom-rule.ts:3:0
 
 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. Found suppression `eslint-disable-next-line my-app/react-rule`.
+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`
 
 error.bailout-on-suppression-of-custom-rule.ts:7:2
    5 |   'use forget';

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.bug-old-inference-false-positive-ref-validation-in-use-effect.expect.md

@@ -1,72 +0,0 @@
-
-## Input
-
-```javascript
-// @validateNoFreezingKnownMutableFunctions @enableNewMutationAliasingModel:false
-
-import {useCallback, useEffect, useRef} from 'react';
-import {useHook} from 'shared-runtime';
-
-function Component() {
-  const params = useHook();
-  const update = useCallback(
-    partialParams => {
-      const nextParams = {
-        ...params,
-        ...partialParams,
-      };
-      nextParams.param = 'value';
-      console.log(nextParams);
-    },
-    [params]
-  );
-  const ref = useRef(null);
-  useEffect(() => {
-    if (ref.current === null) {
-      update();
-    }
-  }, [update]);
-
-  return 'ok';
-}
-
-```
-
-
-## Error
-
-```
-Found 1 error:
-
-Error: Cannot modify local variables after render completes
-
-This argument is a function which may reassign or mutate a variable after render, which can cause inconsistent behavior on subsequent renders. Consider using state instead.
-
-error.bug-old-inference-false-positive-ref-validation-in-use-effect.ts:20:12
-  18 |   );
-  19 |   const ref = useRef(null);
-> 20 |   useEffect(() => {
-     |             ^^^^^^^
-> 21 |     if (ref.current === null) {
-     | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-> 22 |       update();
-     | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-> 23 |     }
-     | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-> 24 |   }, [update]);
-     | ^^^^ This function may (indirectly) reassign or modify a local variable after render
-  25 |
-  26 |   return 'ok';
-  27 | }
-
-error.bug-old-inference-false-positive-ref-validation-in-use-effect.ts:14:6
-  12 |         ...partialParams,
-  13 |       };
-> 14 |       nextParams.param = 'value';
-     |       ^^^^^^^^^^ This modifies a local variable
-  15 |       console.log(nextParams);
-  16 |     },
-  17 |     [params]
-```
-          
-      

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.bug-old-inference-false-positive-ref-validation-in-use-effect.js

@@ -1,27 +0,0 @@
-// @validateNoFreezingKnownMutableFunctions @enableNewMutationAliasingModel:false
-
-import {useCallback, useEffect, useRef} from 'react';
-import {useHook} from 'shared-runtime';
-
-function Component() {
-  const params = useHook();
-  const update = useCallback(
-    partialParams => {
-      const nextParams = {
-        ...params,
-        ...partialParams,
-      };
-      nextParams.param = 'value';
-      console.log(nextParams);
-    },
-    [params]
-  );
-  const ref = useRef(null);
-  useEffect(() => {
-    if (ref.current === null) {
-      update();
-    }
-  }, [update]);
-
-  return 'ok';
-}

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.capitalized-function-call-aliased.expect.md

@@ -18,7 +18,7 @@ Found 1 error:
 
 Error: Capitalized functions are reserved for components, which must be invoked with JSX. If this is a component, render it with JSX. Otherwise, ensure that it has no hook calls and rename it to begin with a lowercase letter. Alternatively, if you know for a fact that this function is not a component, you can allowlist it via the compiler config
 
-Bar may be a component.
+Bar may be a component..
 
 error.capitalized-function-call-aliased.ts:4:2
   2 | function Foo() {

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.capitalized-function-call.expect.md

@@ -19,7 +19,7 @@ Found 1 error:
 
 Error: Capitalized functions are reserved for components, which must be invoked with JSX. If this is a component, render it with JSX. Otherwise, ensure that it has no hook calls and rename it to begin with a lowercase letter. Alternatively, if you know for a fact that this function is not a component, you can allowlist it via the compiler config
 
-SomeFunc may be a component.
+SomeFunc may be a component..
 
 error.capitalized-function-call.ts:3:12
   1 | // @validateNoCapitalizedCalls

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.capitalized-method-call.expect.md

@@ -19,7 +19,7 @@ Found 1 error:
 
 Error: Capitalized functions are reserved for components, which must be invoked with JSX. If this is a component, render it with JSX. Otherwise, ensure that it has no hook calls and rename it to begin with a lowercase letter. Alternatively, if you know for a fact that this function is not a component, you can allowlist it via the compiler config
 
-SomeFunc may be a component.
+SomeFunc may be a component..
 
 error.capitalized-method-call.ts:3:12
   1 | // @validateNoCapitalizedCalls

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

@@ -36,7 +36,7 @@ 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).
+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 |   };
@@ -49,7 +49,7 @@ error.capture-ref-for-mutation.ts:12: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).
+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:15:13
   13 |   };

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.context-variable-only-chained-assign.expect.md

@@ -30,9 +30,9 @@ export const FIXTURE_ENTRYPOINT = {
 ```
 Found 1 error:
 
-Error: Cannot reassign local variables after render completes
+Error: Cannot reassign variable after render completes
 
-Reassigning local variables after render has completed can cause inconsistent behavior on subsequent renders. Consider using state instead.
+Reassigning `x` after render has completed can cause inconsistent behavior on subsequent renders. Consider using state instead.
 
 error.context-variable-only-chained-assign.ts:10:19
    8 |   };

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.declare-reassign-variable-in-function-declaration.expect.md

@@ -19,9 +19,9 @@ function Component() {
 ```
 Found 1 error:
 
-Error: Cannot reassign local variables after render completes
+Error: Cannot reassign variable after render completes
 
-Reassigning local variables after render has completed can cause inconsistent behavior on subsequent renders. Consider using state instead.
+Reassigning `x` after render has completed can cause inconsistent behavior on subsequent renders. Consider using state instead.
 
 error.declare-reassign-variable-in-function-declaration.ts:4:4
   2 |   let x = null;

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.function-expression-references-variable-its-assigned-to.expect.md

@@ -17,9 +17,9 @@ function Component() {
 ```
 Found 1 error:
 
-Error: Cannot reassign local variables after render completes
+Error: Cannot reassign variable after render completes
 
-Reassigning local variables after render has completed can cause inconsistent behavior on subsequent renders. Consider using state instead.
+Reassigning `callback` after render has completed can cause inconsistent behavior on subsequent renders. Consider using state instead.
 
 error.function-expression-references-variable-its-assigned-to.ts:3:4
   1 | function Component() {

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

@@ -24,7 +24,7 @@ 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).
+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.hook-ref-value.ts:5:23
   3 | function Component(props) {
@@ -37,7 +37,7 @@ error.hook-ref-value.ts:5:23
 
 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).
+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.hook-ref-value.ts:5:23
   3 | function Component(props) {

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

@@ -19,7 +19,7 @@ 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).
+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.invalid-access-ref-during-render.ts:4:16
   2 | function Component(props) {

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.invalid-access-ref-in-reducer-init.expect.md

@@ -30,7 +30,7 @@ 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).
+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.invalid-access-ref-in-reducer-init.ts:8:4
    6 |     (state, action) => state + action,

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

@@ -26,7 +26,7 @@ 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).
+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.invalid-access-ref-in-reducer.ts:5:29
   3 | function Component(props) {

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.invalid-access-ref-in-render-mutate-object-with-ref-function.expect.md

@@ -22,7 +22,7 @@ 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).
+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.invalid-access-ref-in-render-mutate-object-with-ref-function.ts:7:19
    5 |   const object = {};

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.invalid-access-ref-in-state-initializer.expect.md

@@ -26,7 +26,7 @@ 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).
+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.invalid-access-ref-in-state-initializer.ts:5:27
   3 | function Component(props) {

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

@@ -23,7 +23,7 @@ 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).
+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.invalid-aliased-ref-in-callback-invoked-during-render-.ts:9:33
    7 |     return <Foo item={item} current={current} />;

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

@@ -22,7 +22,7 @@ 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).
+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();

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.invalid-assing-to-ref-current-in-render.expect.md

@@ -0,0 +1,36 @@
+
+## Input
+
+```javascript
+// @flow
+
+component Foo() {
+  const foo = useFoo();
+  foo.current = true;
+  return <div />;
+}
+
+```
+
+
+## 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.
+
+  3 | component Foo() {
+  4 |   const foo = useFoo();
+> 5 |   foo.current = true;
+    |   ^^^ value cannot be modified
+  6 |   return <div />;
+  7 | }
+  8 |
+
+Hint: If this value is a Ref (value returned by `useRef()`), rename the variable to end in "Ref".
+```
+          
+      

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.invalid-assing-to-ref-current-in-render.js

@@ -0,0 +1,7 @@
+// @flow
+
+component Foo() {
+  const foo = useFoo();
+  foo.current = true;
+  return <div />;
+}

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

@@ -26,7 +26,7 @@ Found 2 errors:
 
 Error: Calling setState from useMemo may trigger an infinite loop
 
-Each time the memo callback is evaluated it will change state. This can cause a memoization dependency to change, running the memo function again and causing an infinite loop. Instead of setting state in useMemo(), prefer deriving the value during render. (https://react.dev/reference/react/useState).
+Each time the memo callback is evaluated it will change state. This can cause a memoization dependency to change, running the memo function again and causing an infinite loop. Instead of setting state in useMemo(), prefer deriving the value during render. (https://react.dev/reference/react/useState)
 
 error.invalid-conditional-setState-in-useMemo.ts:7:6
    5 |   useMemo(() => {
@@ -39,7 +39,7 @@ error.invalid-conditional-setState-in-useMemo.ts:7:6
 
 Error: Calling setState from useMemo may trigger an infinite loop
 
-Each time the memo callback is evaluated it will change state. This can cause a memoization dependency to change, running the memo function again and causing an infinite loop. Instead of setting state in useMemo(), prefer deriving the value during render. (https://react.dev/reference/react/useState).
+Each time the memo callback is evaluated it will change state. This can cause a memoization dependency to change, running the memo function again and causing an infinite loop. Instead of setting state in useMemo(), prefer deriving the value during render. (https://react.dev/reference/react/useState)
 
 error.invalid-conditional-setState-in-useMemo.ts:8:6
    6 |     if (cond) {

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.invalid-destructure-assignment-to-global.expect.md

@@ -17,12 +17,12 @@ Found 1 error:
 
 Error: Cannot reassign variables declared outside of the component/hook
 
-Reassigning this value during render is a form of side effect, which can cause unpredictable behavior depending on when the component happens to re-render. If this variable is used in rendering, use useState instead. Otherwise, consider updating it in an effect. (https://react.dev/reference/rules/components-and-hooks-must-be-pure#side-effects-must-run-outside-of-render).
+Variable `x` is declared outside of the component/hook. Reassigning this value during render is a form of side effect, which can cause unpredictable behavior depending on when the component happens to re-render. If this variable is used in rendering, use useState instead. Otherwise, consider updating it in an effect. (https://react.dev/reference/rules/components-and-hooks-must-be-pure#side-effects-must-run-outside-of-render)
 
 error.invalid-destructure-assignment-to-global.ts:2:3
   1 | function useFoo(props) {
 > 2 |   [x] = props;
-    |    ^ `x` should not be reassigned
+    |    ^ `x` cannot be reassigned
   3 |   return {x};
   4 | }
   5 |

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.invalid-destructure-to-local-global-variables.expect.md

@@ -19,13 +19,13 @@ Found 1 error:
 
 Error: Cannot reassign variables declared outside of the component/hook
 
-Reassigning this value during render is a form of side effect, which can cause unpredictable behavior depending on when the component happens to re-render. If this variable is used in rendering, use useState instead. Otherwise, consider updating it in an effect. (https://react.dev/reference/rules/components-and-hooks-must-be-pure#side-effects-must-run-outside-of-render).
+Variable `b` is declared outside of the component/hook. Reassigning this value during render is a form of side effect, which can cause unpredictable behavior depending on when the component happens to re-render. If this variable is used in rendering, use useState instead. Otherwise, consider updating it in an effect. (https://react.dev/reference/rules/components-and-hooks-must-be-pure#side-effects-must-run-outside-of-render)
 
 error.invalid-destructure-to-local-global-variables.ts:3:6
   1 | function Component(props) {
   2 |   let a;
 > 3 |   [a, b] = props.value;
-    |       ^ `b` should not be reassigned
+    |       ^ `b` cannot be reassigned
   4 |
   5 |   return [a, b];
   6 | }

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

@@ -20,7 +20,7 @@ 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).
+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.invalid-disallow-mutating-ref-in-render.ts:4:2
   2 | function Component() {

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

@@ -25,7 +25,7 @@ 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).
+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.invalid-disallow-mutating-refs-in-render-transitive.ts:9:2
    7 |   };

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.invalid-function-expression-mutates-immutable-value.expect.md

@@ -22,7 +22,7 @@ Found 1 error:
 
 Error: This value cannot be modified
 
-Modifying a value returned from 'useState()', which cannot be modified directly. Use the setter function to update instead.
+Modifying a value returned from 'useState()', which should not be modified directly. Use the setter function to update instead.
 
 error.invalid-function-expression-mutates-immutable-value.ts:5:4
   3 |   const onChange = e => {

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.invalid-global-reassignment-indirect.expect.md

@@ -39,13 +39,13 @@ Found 1 error:
 
 Error: Cannot reassign variables declared outside of the component/hook
 
-Reassigning this value during render is a form of side effect, which can cause unpredictable behavior depending on when the component happens to re-render. If this variable is used in rendering, use useState instead. Otherwise, consider updating it in an effect. (https://react.dev/reference/rules/components-and-hooks-must-be-pure#side-effects-must-run-outside-of-render).
+Variable `someGlobal` is declared outside of the component/hook. Reassigning this value during render is a form of side effect, which can cause unpredictable behavior depending on when the component happens to re-render. If this variable is used in rendering, use useState instead. Otherwise, consider updating it in an effect. (https://react.dev/reference/rules/components-and-hooks-must-be-pure#side-effects-must-run-outside-of-render)
 
 error.invalid-global-reassignment-indirect.ts:9:4
    7 |
    8 |   const setGlobal = () => {
 >  9 |     someGlobal = true;
-     |     ^^^^^^^^^^ `someGlobal` should not be reassigned
+     |     ^^^^^^^^^^ `someGlobal` cannot be reassigned
   10 |   };
   11 |   const indirectSetGlobal = () => {
   12 |     setGlobal();

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.invalid-hoisting-setstate.expect.md

@@ -42,13 +42,13 @@ Found 1 error:
 
 Error: Cannot access variable before it is declared
 
-Reading a variable before it is initialized will prevent the earlier access from updating when this value changes over time. Instead, move the variable access to after it has been initialized.
+`setState` is accessed before it is declared, which prevents the earlier access from updating when this value changes over time.
 
 error.invalid-hoisting-setstate.ts:19:18
   17 |    * $2 = Function context=setState
   18 |    */
 > 19 |   useEffect(() => setState(2), []);
-     |                   ^^^^^^^^ `setState` is accessed before it is declared
+     |                   ^^^^^^^^ `setState` accessed before it is declared
   20 |
   21 |   const [state, setState] = useState(0);
   22 |   return <Stringify state={state} />;

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.invalid-hook-function-argument-mutates-local-variable.expect.md

@@ -21,7 +21,7 @@ Found 1 error:
 
 Error: Cannot modify local variables after render completes
 
-This argument is a function which may reassign or mutate a variable after render, which can cause inconsistent behavior on subsequent renders. Consider using state instead.
+This argument is a function which may reassign or mutate `cache` after render, which can cause inconsistent behavior on subsequent renders. Consider using state instead.
 
 error.invalid-hook-function-argument-mutates-local-variable.ts:5:10
   3 | function useFoo() {

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.invalid-impure-functions-in-render.expect.md

@@ -19,41 +19,41 @@ function Component() {
 ```
 Found 3 errors:
 
-Error: Cannot call impure functions during render
+Error: Cannot call impure function during render
 
-Calling an impure function can produce unstable results that change unpredictably when the component happens to re-render. (https://react.dev/reference/rules/components-and-hooks-must-be-pure#components-and-hooks-must-be-idempotent).
+`Date.now` is an impure function. Calling an impure function can produce unstable results that update unpredictably when the component happens to re-render. (https://react.dev/reference/rules/components-and-hooks-must-be-pure#components-and-hooks-must-be-idempotent)
 
 error.invalid-impure-functions-in-render.ts:4:15
   2 |
   3 | function Component() {
 > 4 |   const date = Date.now();
-    |                ^^^^^^^^^^ `Date.now` is an impure function. 
+    |                ^^^^^^^^^^ Cannot call impure function
   5 |   const now = performance.now();
   6 |   const rand = Math.random();
   7 |   return <Foo date={date} now={now} rand={rand} />;
 
-Error: Cannot call impure functions during render
+Error: Cannot call impure function during render
 
-Calling an impure function can produce unstable results that change unpredictably when the component happens to re-render. (https://react.dev/reference/rules/components-and-hooks-must-be-pure#components-and-hooks-must-be-idempotent).
+`performance.now` is an impure function. Calling an impure function can produce unstable results that update unpredictably when the component happens to re-render. (https://react.dev/reference/rules/components-and-hooks-must-be-pure#components-and-hooks-must-be-idempotent)
 
 error.invalid-impure-functions-in-render.ts:5:14
   3 | function Component() {
   4 |   const date = Date.now();
 > 5 |   const now = performance.now();
-    |               ^^^^^^^^^^^^^^^^^ `performance.now` is an impure function. 
+    |               ^^^^^^^^^^^^^^^^^ Cannot call impure function
   6 |   const rand = Math.random();
   7 |   return <Foo date={date} now={now} rand={rand} />;
   8 | }
 
-Error: Cannot call impure functions during render
+Error: Cannot call impure function during render
 
-Calling an impure function can produce unstable results that change unpredictably when the component happens to re-render. (https://react.dev/reference/rules/components-and-hooks-must-be-pure#components-and-hooks-must-be-idempotent).
+`Math.random` is an impure function. Calling an impure function can produce unstable results that update unpredictably when the component happens to re-render. (https://react.dev/reference/rules/components-and-hooks-must-be-pure#components-and-hooks-must-be-idempotent)
 
 error.invalid-impure-functions-in-render.ts:6:15
   4 |   const date = Date.now();
   5 |   const now = performance.now();
 > 6 |   const rand = Math.random();
-    |                ^^^^^^^^^^^^^ `Math.random` is an impure function. 
+    |                ^^^^^^^^^^^^^ Cannot call impure function
   7 |   return <Foo date={date} now={now} rand={rand} />;
   8 | }
   9 |

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.invalid-mutate-context-in-callback.expect.md

@@ -28,7 +28,7 @@ Found 1 error:
 
 Error: This value cannot be modified
 
-Modifying a value returned from 'useContext()' is not allowed.
+Modifying a value returned from 'useContext()' is not allowed..
 
 error.invalid-mutate-context-in-callback.ts:12:4
   10 |   // independently

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.invalid-mutate-context.expect.md

@@ -18,7 +18,7 @@ Found 1 error:
 
 Error: This value cannot be modified
 
-Modifying a value returned from 'useContext()' is not allowed.
+Modifying a value returned from 'useContext()' is not allowed..
 
 error.invalid-mutate-context.ts:3:2
   1 | function Component(props) {