babel-plugin-react-compiler 19.1.0-rc.1 → 19.1.0-rc.3

package/dist/index.d.ts

@@ -2,7 +2,7 @@ import * as BabelCore from '@babel/core';
 import { NodePath as NodePath$1 } from '@babel/core';
 import * as t from '@babel/types';
 import { z } from 'zod';
-import { Scope, NodePath } from '@babel/traverse';
+import { NodePath, Scope } from '@babel/traverse';
 
 interface Result<T, E> {
     map<U>(fn: (val: T) => U): Result<U, E>;
@@ -23,7 +23,7 @@ interface Result<T, E> {
     unwrapErr(): E;
 }
 declare class OkImpl<T> implements Result<T, never> {
-    private val;
+    #private;
     constructor(val: T);
     map<U>(fn: (val: T) => U): Result<U, never>;
     mapErr<F>(_fn: (val: never) => F): Result<T, F>;
@@ -43,7 +43,7 @@ declare class OkImpl<T> implements Result<T, never> {
     unwrapErr(): never;
 }
 declare class ErrImpl<E> implements Result<never, E> {
-    private val;
+    #private;
     constructor(val: E);
     map<U>(_fn: (val: never) => U): Result<U, E>;
     mapErr<F>(fn: (val: E) => F): Result<never, F>;
@@ -63,6 +63,94 @@ declare class ErrImpl<E> implements Result<never, E> {
     unwrapErr(): E;
 }
 
+type AliasingEffect = {
+    kind: 'Freeze';
+    value: Place;
+    reason: ValueReason;
+} | {
+    kind: 'Mutate';
+    value: Place;
+    reason?: MutationReason | null;
+} | {
+    kind: 'MutateConditionally';
+    value: Place;
+} | {
+    kind: 'MutateTransitive';
+    value: Place;
+} | {
+    kind: 'MutateTransitiveConditionally';
+    value: Place;
+} | {
+    kind: 'Capture';
+    from: Place;
+    into: Place;
+} | {
+    kind: 'Alias';
+    from: Place;
+    into: Place;
+} | {
+    kind: 'MaybeAlias';
+    from: Place;
+    into: Place;
+} | {
+    kind: 'Assign';
+    from: Place;
+    into: Place;
+} | {
+    kind: 'Create';
+    into: Place;
+    value: ValueKind;
+    reason: ValueReason;
+} | {
+    kind: 'CreateFrom';
+    from: Place;
+    into: Place;
+} | {
+    kind: 'ImmutableCapture';
+    from: Place;
+    into: Place;
+} | {
+    kind: 'Apply';
+    receiver: Place;
+    function: Place;
+    mutatesFunction: boolean;
+    args: Array<Place | SpreadPattern | Hole>;
+    into: Place;
+    signature: FunctionSignature | null;
+    loc: SourceLocation;
+} | {
+    kind: 'CreateFunction';
+    captures: Array<Place>;
+    function: FunctionExpression | ObjectMethod;
+    into: Place;
+} | {
+    kind: 'MutateFrozen';
+    place: Place;
+    error: CompilerDiagnostic;
+} | {
+    kind: 'MutateGlobal';
+    place: Place;
+    error: CompilerDiagnostic;
+} | {
+    kind: 'Impure';
+    place: Place;
+    error: CompilerDiagnostic;
+} | {
+    kind: 'Render';
+    place: Place;
+};
+type MutationReason = {
+    kind: 'AssignCurrentProperty';
+};
+type AliasingSignature = {
+    receiver: IdentifierId;
+    params: Array<IdentifierId>;
+    rest: IdentifierId | null;
+    returns: IdentifierId;
+    effects: Array<AliasingEffect>;
+    temporaries: Array<Place>;
+};
+
 type BuiltInType = PrimitiveType | FunctionType | ObjectType;
 type Type = BuiltInType | PhiType | TypeVar | PolyType | PropType | ObjectMethod$1;
 type PrimitiveType = {
@@ -109,7 +197,7 @@ type TypeId = number & {
     [opaqueTypeId]: 'IdentifierId';
 };
 
-type HookKind = 'useContext' | 'useState' | 'useActionState' | 'useReducer' | 'useRef' | 'useEffect' | 'useLayoutEffect' | 'useInsertionEffect' | 'useMemo' | 'useCallback' | 'useTransition' | 'useImperativeHandle' | 'Custom';
+type HookKind = 'useContext' | 'useState' | 'useActionState' | 'useReducer' | 'useRef' | 'useEffect' | 'useLayoutEffect' | 'useInsertionEffect' | 'useMemo' | 'useCallback' | 'useTransition' | 'useImperativeHandle' | 'useEffectEvent' | 'Custom';
 type FunctionSignature = {
     positionalParams: Array<Effect>;
     restParam: Effect | null;
@@ -122,10 +210,126 @@ type FunctionSignature = {
     mutableOnlyIfOperandsAreMutable?: boolean;
     impure?: boolean;
     canonicalName?: string;
+    aliasing?: AliasingSignature | null | undefined;
 };
 
 type Global = BuiltInType | PolyType;
 
+type ResolvedType = {
+    kind: 'Concrete';
+    type: ConcreteType<ResolvedType>;
+    platform: Platform;
+};
+type ComponentType<T> = {
+    kind: 'Component';
+    props: Map<string, T>;
+    children: null | T;
+};
+type ConcreteType<T> = {
+    kind: 'Enum';
+} | {
+    kind: 'Mixed';
+} | {
+    kind: 'Number';
+} | {
+    kind: 'String';
+} | {
+    kind: 'Boolean';
+} | {
+    kind: 'Void';
+} | {
+    kind: 'Nullable';
+    type: T;
+} | {
+    kind: 'Array';
+    element: T;
+} | {
+    kind: 'Set';
+    element: T;
+} | {
+    kind: 'Map';
+    key: T;
+    value: T;
+} | {
+    kind: 'Function';
+    typeParameters: null | Array<TypeParameter<T>>;
+    params: Array<T>;
+    returnType: T;
+} | ComponentType<T> | {
+    kind: 'Generic';
+    id: TypeParameterId;
+    bound: T;
+} | {
+    kind: 'Object';
+    id: NominalId;
+    members: Map<string, ResolvedType>;
+} | {
+    kind: 'Tuple';
+    id: NominalId;
+    members: Array<T>;
+} | {
+    kind: 'Structural';
+    id: LinearId;
+} | {
+    kind: 'Union';
+    members: Array<T>;
+} | {
+    kind: 'Instance';
+    name: string;
+    members: Map<string, ResolvedType>;
+};
+type TypeParameter<T> = {
+    name: string;
+    id: TypeParameterId;
+    bound: T;
+};
+declare const opaqueLinearId: unique symbol;
+type LinearId = number & {
+    [opaqueLinearId]: 'LinearId';
+};
+declare const opaqueTypeParameterId: unique symbol;
+type TypeParameterId = number & {
+    [opaqueTypeParameterId]: 'TypeParameterId';
+};
+declare const opaqueNominalId: unique symbol;
+type NominalId = number & {
+    [opaqueNominalId]: 'NominalId';
+};
+type Platform = 'client' | 'server' | 'shared';
+interface ITypeEnv {
+    popGeneric(name: string): void;
+    getGeneric(name: string): null | TypeParameter<ResolvedType>;
+    pushGeneric(name: string, binding: {
+        name: string;
+        id: TypeParameterId;
+        bound: ResolvedType;
+    }): void;
+    getType(id: Identifier): ResolvedType;
+    getTypeOrNull(id: Identifier): ResolvedType | null;
+    setType(id: Identifier, type: ResolvedType): void;
+    nextNominalId(): NominalId;
+    nextTypeParameterId(): TypeParameterId;
+    moduleEnv: Map<string, ResolvedType>;
+    addBinding(bindingIdentifier: t.Identifier, type: ResolvedType): void;
+    resolveBinding(bindingIdentifier: t.Identifier): ResolvedType | null;
+}
+declare class FlowTypeEnv implements ITypeEnv {
+    #private;
+    moduleEnv: Map<string, ResolvedType>;
+    init(env: Environment, source: string): void;
+    setType(identifier: Identifier, type: ResolvedType): void;
+    getType(identifier: Identifier): ResolvedType;
+    getTypeOrNull(identifier: Identifier): ResolvedType | null;
+    getTypeByLoc(loc: SourceLocation): ResolvedType | null;
+    nextNominalId(): NominalId;
+    nextTypeParameterId(): TypeParameterId;
+    addBinding(bindingIdentifier: t.Identifier, type: ResolvedType): void;
+    resolveBinding(bindingIdentifier: t.Identifier): ResolvedType | null;
+    pushGeneric(name: string, generic: TypeParameter<ResolvedType>): void;
+    popGeneric(name: string): void;
+    getGeneric(name: string): null | TypeParameter<ResolvedType>;
+}
+
 declare const ExternalFunctionSchema: z.ZodObject<{
     source: z.ZodString;
     importSpecifierName: z.ZodString;
@@ -195,6 +399,7 @@ declare const EnvironmentConfigSchema: z.ZodObject<{
     enablePreserveExistingManualUseMemo: z.ZodDefault<z.ZodBoolean>;
     enableForest: z.ZodDefault<z.ZodBoolean>;
     enableUseTypeAnnotations: z.ZodDefault<z.ZodBoolean>;
+    flowTypeProvider: z.ZodDefault<z.ZodNullable<z.ZodFunction<z.ZodTuple<[z.ZodString], z.ZodUnknown>, z.ZodUnknown>>>;
     enableOptionalDependencies: z.ZodDefault<z.ZodBoolean>;
     enableFire: z.ZodDefault<z.ZodBoolean>;
     inferEffectDependencies: z.ZodDefault<z.ZodNullable<z.ZodArray<z.ZodObject<{
@@ -208,19 +413,19 @@ declare const EnvironmentConfigSchema: z.ZodObject<{
             source: string;
             importSpecifierName: string;
         }>;
-        numRequiredArgs: z.ZodNumber;
+        autodepsIndex: z.ZodNumber;
     }, "strip", z.ZodTypeAny, {
         function: {
             source: string;
             importSpecifierName: string;
         };
-        numRequiredArgs: number;
+        autodepsIndex: number;
     }, {
         function: {
             source: string;
             importSpecifierName: string;
         };
-        numRequiredArgs: number;
+        autodepsIndex: number;
     }>, "many">>>;
     inlineJsxTransform: z.ZodDefault<z.ZodNullable<z.ZodObject<{
         elementSymbol: z.ZodUnion<[z.ZodLiteral<"react.element">, z.ZodLiteral<"react.transitional.element">]>;
@@ -235,13 +440,15 @@ declare const EnvironmentConfigSchema: z.ZodObject<{
     validateHooksUsage: z.ZodDefault<z.ZodBoolean>;
     validateRefAccessDuringRender: z.ZodDefault<z.ZodBoolean>;
     validateNoSetStateInRender: z.ZodDefault<z.ZodBoolean>;
-    validateNoSetStateInPassiveEffects: z.ZodDefault<z.ZodBoolean>;
+    validateNoSetStateInEffects: z.ZodDefault<z.ZodBoolean>;
+    validateNoDerivedComputationsInEffects: z.ZodDefault<z.ZodBoolean>;
     validateNoJSXInTryStatements: z.ZodDefault<z.ZodBoolean>;
     validateStaticComponents: z.ZodDefault<z.ZodBoolean>;
     validateMemoizedEffectDependencies: z.ZodDefault<z.ZodBoolean>;
     validateNoCapitalizedCalls: z.ZodDefault<z.ZodNullable<z.ZodArray<z.ZodString, "many">>>;
     validateBlocklistedImports: z.ZodDefault<z.ZodNullable<z.ZodArray<z.ZodString, "many">>>;
     validateNoImpureFunctionsInRender: z.ZodDefault<z.ZodBoolean>;
+    validateNoFreezingKnownMutableFunctions: z.ZodDefault<z.ZodBoolean>;
     enableAssumeHooksFollowRulesOfReact: z.ZodDefault<z.ZodBoolean>;
     enableTransitivelyFreezeFunctionExpressions: z.ZodDefault<z.ZodBoolean>;
     enableEmitFreeze: z.ZodDefault<z.ZodNullable<z.ZodObject<{
@@ -359,6 +566,8 @@ declare const EnvironmentConfigSchema: z.ZodObject<{
         source: string;
         importSpecifierName: string;
     }>>>;
+    validateNoVoidUseMemo: z.ZodDefault<z.ZodBoolean>;
+    validateNoDynamicallyCreatedComponentsOrHooks: z.ZodDefault<z.ZodBoolean>;
 }, "strip", z.ZodTypeAny, {
     customHooks: Map<string, {
         noAlias: boolean;
@@ -379,6 +588,7 @@ declare const EnvironmentConfigSchema: z.ZodObject<{
     enablePreserveExistingManualUseMemo: boolean;
     enableForest: boolean;
     enableUseTypeAnnotations: boolean;
+    flowTypeProvider: ((args_0: string, ...args_1: unknown[]) => unknown) | null;
     enableOptionalDependencies: boolean;
     enableFire: boolean;
     inferEffectDependencies: {
@@ -386,7 +596,7 @@ declare const EnvironmentConfigSchema: z.ZodObject<{
             source: string;
             importSpecifierName: string;
         };
-        numRequiredArgs: number;
+        autodepsIndex: number;
     }[] | null;
     inlineJsxTransform: {
         elementSymbol: "react.element" | "react.transitional.element";
@@ -395,13 +605,15 @@ declare const EnvironmentConfigSchema: z.ZodObject<{
     validateHooksUsage: boolean;
     validateRefAccessDuringRender: boolean;
     validateNoSetStateInRender: boolean;
-    validateNoSetStateInPassiveEffects: boolean;
+    validateNoSetStateInEffects: boolean;
+    validateNoDerivedComputationsInEffects: boolean;
     validateNoJSXInTryStatements: boolean;
     validateStaticComponents: boolean;
     validateMemoizedEffectDependencies: boolean;
     validateNoCapitalizedCalls: string[] | null;
     validateBlocklistedImports: string[] | null;
     validateNoImpureFunctionsInRender: boolean;
+    validateNoFreezingKnownMutableFunctions: boolean;
     enableAssumeHooksFollowRulesOfReact: boolean;
     enableTransitivelyFreezeFunctionExpressions: boolean;
     enableEmitFreeze: {
@@ -443,6 +655,8 @@ declare const EnvironmentConfigSchema: z.ZodObject<{
         source: string;
         importSpecifierName: string;
     } | null;
+    validateNoVoidUseMemo: boolean;
+    validateNoDynamicallyCreatedComponentsOrHooks: boolean;
 }, {
     customHooks?: Map<string, {
         effectKind: Effect;
@@ -463,6 +677,7 @@ declare const EnvironmentConfigSchema: z.ZodObject<{
     enablePreserveExistingManualUseMemo?: boolean | undefined;
     enableForest?: boolean | undefined;
     enableUseTypeAnnotations?: boolean | undefined;
+    flowTypeProvider?: ((args_0: string, ...args_1: unknown[]) => unknown) | null | undefined;
     enableOptionalDependencies?: boolean | undefined;
     enableFire?: boolean | undefined;
     inferEffectDependencies?: {
@@ -470,7 +685,7 @@ declare const EnvironmentConfigSchema: z.ZodObject<{
             source: string;
             importSpecifierName: string;
         };
-        numRequiredArgs: number;
+        autodepsIndex: number;
     }[] | null | undefined;
     inlineJsxTransform?: {
         elementSymbol: "react.element" | "react.transitional.element";
@@ -479,13 +694,15 @@ declare const EnvironmentConfigSchema: z.ZodObject<{
     validateHooksUsage?: boolean | undefined;
     validateRefAccessDuringRender?: boolean | undefined;
     validateNoSetStateInRender?: boolean | undefined;
-    validateNoSetStateInPassiveEffects?: boolean | undefined;
+    validateNoSetStateInEffects?: boolean | undefined;
+    validateNoDerivedComputationsInEffects?: boolean | undefined;
     validateNoJSXInTryStatements?: boolean | undefined;
     validateStaticComponents?: boolean | undefined;
     validateMemoizedEffectDependencies?: boolean | undefined;
     validateNoCapitalizedCalls?: string[] | null | undefined;
     validateBlocklistedImports?: string[] | null | undefined;
     validateNoImpureFunctionsInRender?: boolean | undefined;
+    validateNoFreezingKnownMutableFunctions?: boolean | undefined;
     enableAssumeHooksFollowRulesOfReact?: boolean | undefined;
     enableTransitivelyFreezeFunctionExpressions?: boolean | undefined;
     enableEmitFreeze?: {
@@ -527,11 +744,10 @@ declare const EnvironmentConfigSchema: z.ZodObject<{
         source: string;
         importSpecifierName: string;
     } | null | undefined;
+    validateNoVoidUseMemo?: boolean | undefined;
+    validateNoDynamicallyCreatedComponentsOrHooks?: boolean | undefined;
 }>;
 type EnvironmentConfig = z.infer<typeof EnvironmentConfigSchema>;
-declare function parseConfigPragmaForTests(pragma: string, defaults: {
-    compilationMode: CompilationMode;
-}): PluginOptions;
 type PartialEnvironmentConfig = Partial<EnvironmentConfig>;
 type ReactFunctionType = 'Component' | 'Hook' | 'Other';
 declare class Environment {
@@ -546,7 +762,9 @@ declare class Environment {
     hasFireRewrite: boolean;
     hasInferredEffect: boolean;
     inferredEffectLocations: Set<SourceLocation>;
-    constructor(scope: Scope, fnType: ReactFunctionType, compilerMode: CompilerMode, config: EnvironmentConfig, contextIdentifiers: Set<t.Identifier>, logger: Logger | null, filename: string | null, code: string | null, programContext: ProgramContext);
+    parentFunction: NodePath<t.Function>;
+    constructor(scope: Scope, fnType: ReactFunctionType, compilerMode: CompilerMode, config: EnvironmentConfig, contextIdentifiers: Set<t.Identifier>, parentFunction: NodePath<t.Function>, logger: Logger | null, filename: string | null, code: string | null, programContext: ProgramContext);
+    get typeContext(): FlowTypeEnv;
     get isInferredMemoEnabled(): boolean;
     get nextIdentifierId(): IdentifierId;
     get nextBlockId(): BlockId;
@@ -610,6 +828,7 @@ type ReactiveInstruction = {
     id: InstructionId;
     lvalue: Place | null;
     value: ReactiveValue;
+    effects?: Array<AliasingEffect> | null;
     loc: SourceLocation;
 };
 type ReactiveValue = InstructionValue | ReactiveLogicalValue | ReactiveSequenceValue | ReactiveTernaryValue | ReactiveOptionalCallValue;
@@ -746,25 +965,13 @@ type HIRFunction = {
     env: Environment;
     params: Array<Place | SpreadPattern>;
     returnTypeAnnotation: t.FlowType | t.TSType | null;
-    returnType: Type;
+    returns: Place;
     context: Array<Place>;
-    effects: Array<FunctionEffect> | null;
     body: HIR;
     generator: boolean;
     async: boolean;
     directives: Array<string>;
-};
-type FunctionEffect = {
-    kind: 'GlobalMutation';
-    error: CompilerErrorDetailOptions;
-} | {
-    kind: 'ReactMutation';
-    error: CompilerErrorDetailOptions;
-} | {
-    kind: 'ContextMutation';
-    places: ReadonlySet<Place>;
-    effect: Effect;
-    loc: SourceLocation;
+    aliasingEffects: Array<AliasingEffect> | null;
 };
 type HIR = {
     entry: BlockId;
@@ -803,12 +1010,15 @@ type Case = {
     test: Place | null;
     block: BlockId;
 };
+type ReturnVariant = 'Void' | 'Implicit' | 'Explicit';
 type ReturnTerminal = {
     kind: 'return';
+    returnVariant: ReturnVariant;
     loc: SourceLocation;
     value: Place;
     id: InstructionId;
     fallthrough?: never;
+    effects: Array<AliasingEffect> | null;
 };
 type GotoTerminal = {
     kind: 'goto';
@@ -945,6 +1155,7 @@ type MaybeThrowTerminal = {
     id: InstructionId;
     loc: SourceLocation;
     fallthrough?: never;
+    effects: Array<AliasingEffect> | null;
 };
 type ReactiveScopeTerminal = {
     kind: 'scope';
@@ -967,6 +1178,7 @@ type Instruction = {
     lvalue: Place;
     value: InstructionValue;
     loc: SourceLocation;
+    effects: Array<AliasingEffect> | null;
 };
 type LValue = {
     place: Place;
@@ -1107,7 +1319,7 @@ type InstructionValue = LoadLocal | LoadContext | {
 } | StoreLocal | {
     kind: 'StoreContext';
     lvalue: {
-        kind: InstructionKind.Reassign;
+        kind: InstructionKind.Reassign | InstructionKind.Const | InstructionKind.Let | InstructionKind.Function;
         place: Place;
     };
     value: Place;
@@ -1357,6 +1569,9 @@ type ValidIdentifierName = string & {
 declare enum ValueReason {
     Global = "global",
     JsxCaptured = "jsx-captured",
+    HookCaptured = "hook-captured",
+    HookReturn = "hook-return",
+    Effect = "effect",
     KnownReturnSignature = "known-return-signature",
     Context = "context",
     State = "state",
@@ -1412,6 +1627,7 @@ type DependencyPathEntry = {
 type DependencyPath = Array<DependencyPathEntry>;
 type ReactiveScopeDependency = {
     identifier: Identifier;
+    reactive: boolean;
     path: DependencyPath;
 };
 declare const opaqueBlockId: unique symbol;
@@ -1443,12 +1659,29 @@ declare function printHIR(ir: HIR, options?: Options | null): string;
 
 declare enum ErrorSeverity {
     InvalidJS = "InvalidJS",
+    UnsupportedJS = "UnsupportedJS",
     InvalidReact = "InvalidReact",
     InvalidConfig = "InvalidConfig",
     CannotPreserveMemoization = "CannotPreserveMemoization",
     Todo = "Todo",
     Invariant = "Invariant"
 }
+type CompilerDiagnosticOptions = {
+    category: ErrorCategory;
+    severity: ErrorSeverity;
+    reason: string;
+    description: string;
+    details: Array<CompilerDiagnosticDetail>;
+    suggestions?: Array<CompilerSuggestion> | null | undefined;
+};
+type CompilerDiagnosticDetail = {
+    kind: 'error';
+    loc: SourceLocation | null;
+    message: string;
+} | {
+    kind: 'hint';
+    message: string;
+};
 declare enum CompilerSuggestionOperation {
     InsertBefore = 0,
     InsertAfter = 1,
@@ -1466,12 +1699,30 @@ type CompilerSuggestion = {
     description: string;
 };
 type CompilerErrorDetailOptions = {
+    category: ErrorCategory;
+    severity: ErrorSeverity;
     reason: string;
     description?: string | null | undefined;
-    severity: ErrorSeverity;
     loc: SourceLocation | null;
     suggestions?: Array<CompilerSuggestion> | null | undefined;
 };
+type PrintErrorMessageOptions = {
+    eslint: boolean;
+};
+declare class CompilerDiagnostic {
+    options: CompilerDiagnosticOptions;
+    constructor(options: CompilerDiagnosticOptions);
+    static create(options: Omit<CompilerDiagnosticOptions, 'details'>): CompilerDiagnostic;
+    get reason(): CompilerDiagnosticOptions['reason'];
+    get description(): CompilerDiagnosticOptions['description'];
+    get severity(): CompilerDiagnosticOptions['severity'];
+    get suggestions(): CompilerDiagnosticOptions['suggestions'];
+    get category(): ErrorCategory;
+    withDetail(detail: CompilerDiagnosticDetail): CompilerDiagnostic;
+    primaryLocation(): SourceLocation | null;
+    printErrorMessage(source: string, options: PrintErrorMessageOptions): string;
+    toString(): string;
+}
 declare class CompilerErrorDetail {
     options: CompilerErrorDetailOptions;
     constructor(options: CompilerErrorDetailOptions);
@@ -1480,27 +1731,69 @@ declare class CompilerErrorDetail {
     get severity(): CompilerErrorDetailOptions['severity'];
     get loc(): CompilerErrorDetailOptions['loc'];
     get suggestions(): CompilerErrorDetailOptions['suggestions'];
-    printErrorMessage(): string;
+    get category(): ErrorCategory;
+    primaryLocation(): SourceLocation | null;
+    printErrorMessage(source: string, options: PrintErrorMessageOptions): string;
     toString(): string;
 }
 declare class CompilerError extends Error {
-    details: Array<CompilerErrorDetail>;
-    static invariant(condition: unknown, options: Omit<CompilerErrorDetailOptions, 'severity'>): asserts condition;
-    static throwTodo(options: Omit<CompilerErrorDetailOptions, 'severity'>): never;
-    static throwInvalidJS(options: Omit<CompilerErrorDetailOptions, 'severity'>): never;
+    details: Array<CompilerErrorDetail | CompilerDiagnostic>;
+    printedMessage: string | null;
+    static invariant(condition: unknown, options: Omit<CompilerErrorDetailOptions, 'severity' | 'category'>): asserts condition;
+    static throwDiagnostic(options: CompilerDiagnosticOptions): never;
+    static throwTodo(options: Omit<CompilerErrorDetailOptions, 'severity' | 'category'>): never;
+    static throwInvalidJS(options: Omit<CompilerErrorDetailOptions, 'severity' | 'category'>): never;
     static throwInvalidReact(options: Omit<CompilerErrorDetailOptions, 'severity'>): never;
-    static throwInvalidConfig(options: Omit<CompilerErrorDetailOptions, 'severity'>): never;
+    static throwInvalidConfig(options: Omit<CompilerErrorDetailOptions, 'severity' | 'category'>): never;
     static throw(options: CompilerErrorDetailOptions): never;
     constructor(...args: Array<any>);
     get message(): string;
     set message(_message: string);
     toString(): string;
+    withPrintedMessage(source: string, options: PrintErrorMessageOptions): CompilerError;
+    printErrorMessage(source: string, options: PrintErrorMessageOptions): string;
+    merge(other: CompilerError): void;
+    pushDiagnostic(diagnostic: CompilerDiagnostic): void;
     push(options: CompilerErrorDetailOptions): CompilerErrorDetail;
     pushErrorDetail(detail: CompilerErrorDetail): CompilerErrorDetail;
     hasErrors(): boolean;
     asResult(): Result<void, CompilerError>;
     isCritical(): boolean;
 }
+declare enum ErrorCategory {
+    Hooks = "Hooks",
+    CapitalizedCalls = "CapitalizedCalls",
+    StaticComponents = "StaticComponents",
+    UseMemo = "UseMemo",
+    Factories = "Factories",
+    PreserveManualMemo = "PreserveManualMemo",
+    Immutability = "Immutability",
+    Globals = "Globals",
+    Refs = "Refs",
+    EffectDependencies = "EffectDependencies",
+    EffectSetState = "EffectSetState",
+    EffectDerivationsOfState = "EffectDerivationsOfState",
+    ErrorBoundaries = "ErrorBoundaries",
+    Purity = "Purity",
+    RenderSetState = "RenderSetState",
+    Invariant = "Invariant",
+    Todo = "Todo",
+    Syntax = "Syntax",
+    UnsupportedSyntax = "UnsupportedSyntax",
+    Config = "Config",
+    Gating = "Gating",
+    Suppression = "Suppression",
+    AutomaticEffectDependencies = "AutomaticEffectDependencies",
+    Fire = "Fire",
+    FBT = "FBT"
+}
+type LintRule = {
+    category: ErrorCategory;
+    name: string;
+    description: string;
+    recommended: boolean;
+};
+declare const LintRules: Array<LintRule>;
 
 type CodegenFunction = {
     type: 'CodegenFunction';
@@ -1548,17 +1841,29 @@ declare function compileFn(func: NodePath<t.FunctionDeclaration | t.ArrowFunctio
 
 declare const PanicThresholdOptionsSchema: z.ZodEnum<["all_errors", "critical_errors", "none"]>;
 type PanicThresholdOptions = z.infer<typeof PanicThresholdOptionsSchema>;
+declare const DynamicGatingOptionsSchema: z.ZodObject<{
+    source: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    source: string;
+}, {
+    source: string;
+}>;
+type DynamicGatingOptions = z.infer<typeof DynamicGatingOptionsSchema>;
+declare const CustomOptOutDirectiveSchema: z.ZodDefault<z.ZodNullable<z.ZodArray<z.ZodString, "many">>>;
+type CustomOptOutDirective = z.infer<typeof CustomOptOutDirectiveSchema>;
 type PluginOptions = {
     environment: EnvironmentConfig;
     logger: Logger | null;
     gating: ExternalFunction | null;
+    dynamicGating: DynamicGatingOptions | null;
     panicThreshold: PanicThresholdOptions;
     noEmit: boolean;
     compilationMode: CompilationMode;
-    eslintSuppressionRules?: Array<string> | null | undefined;
+    eslintSuppressionRules: Array<string> | null | undefined;
     flowSuppressions: boolean;
     ignoreUseNoForget: boolean;
-    sources?: Array<string> | ((filename: string) => boolean) | null;
+    customOptOutDirectives: CustomOptOutDirective;
+    sources: Array<string> | ((filename: string) => boolean) | null;
     enableReanimatedCheck: boolean;
     target: CompilerReactTarget;
 };
@@ -1575,11 +1880,11 @@ declare const CompilerReactTargetSchema: z.ZodUnion<[z.ZodLiteral<"17">, z.ZodLi
 type CompilerReactTarget = z.infer<typeof CompilerReactTargetSchema>;
 declare const CompilationModeSchema: z.ZodEnum<["infer", "syntax", "annotation", "all"]>;
 type CompilationMode = z.infer<typeof CompilationModeSchema>;
-type LoggerEvent = CompileSuccessEvent | CompileErrorEvent | CompileDiagnosticEvent | CompileSkipEvent | PipelineErrorEvent | TimingEvent;
+type LoggerEvent = CompileSuccessEvent | CompileErrorEvent | CompileDiagnosticEvent | CompileSkipEvent | PipelineErrorEvent | TimingEvent | AutoDepsDecorationsEvent | AutoDepsEligibleEvent;
 type CompileErrorEvent = {
     kind: 'CompileError';
     fnLoc: t.SourceLocation | null;
-    detail: CompilerErrorDetailOptions;
+    detail: CompilerErrorDetail | CompilerDiagnostic;
 };
 type CompileDiagnosticEvent = {
     kind: 'CompileDiagnostic';
@@ -1611,28 +1916,22 @@ type TimingEvent = {
     kind: 'Timing';
     measurement: PerformanceMeasure;
 };
+type AutoDepsDecorationsEvent = {
+    kind: 'AutoDepsDecorations';
+    fnLoc: t.SourceLocation;
+    decorations: Array<t.SourceLocation>;
+};
+type AutoDepsEligibleEvent = {
+    kind: 'AutoDepsEligible';
+    fnLoc: t.SourceLocation;
+    depArrayLoc: t.SourceLocation;
+};
 type Logger = {
     logEvent: (filename: string | null, event: LoggerEvent) => void;
     debugLogIRs?: (value: CompilerPipelineValue) => void;
 };
 declare function parsePluginOptions(obj: unknown): PluginOptions;
 
-declare class ProgramContext {
-    scope: Scope;
-    reactRuntimeModule: string;
-    hookPattern: string | null;
-    knownReferencedNames: Set<string>;
-    imports: Map<string, Map<string, NonLocalImportSpecifier>>;
-    constructor(program: NodePath$1<t.Program>, reactRuntimeModule: CompilerReactTarget, hookPattern: string | null);
-    isHookName(name: string): boolean;
-    hasReference(name: string): boolean;
-    newUid(name: string): string;
-    addMemoCacheImport(): NonLocalImportSpecifier;
-    addImportSpecifier({ source: module, importSpecifierName: specifier }: ExternalFunction, nameHint?: string): NonLocalImportSpecifier;
-    addNewReference(name: string): void;
-    assertGlobalBinding(name: string, localScope?: Scope): Result<void, CompilerError>;
-}
-
 type CompilerPass = {
     opts: PluginOptions;
     filename: string | null;
@@ -1641,24 +1940,72 @@ type CompilerPass = {
 };
 declare const OPT_IN_DIRECTIVES: Set<string>;
 declare const OPT_OUT_DIRECTIVES: Set<string>;
-declare function findDirectiveEnablingMemoization(directives: Array<t.Directive>): Array<t.Directive>;
-declare function findDirectiveDisablingMemoization(directives: Array<t.Directive>): Array<t.Directive>;
+declare function tryFindDirectiveEnablingMemoization(directives: Array<t.Directive>, opts: PluginOptions): Result<t.Directive | null, CompilerError>;
+declare function findDirectiveDisablingMemoization(directives: Array<t.Directive>, { customOptOutDirectives }: PluginOptions): t.Directive | null;
 type BabelFn = NodePath$1<t.FunctionDeclaration> | NodePath$1<t.FunctionExpression> | NodePath$1<t.ArrowFunctionExpression>;
-type CompileProgramResult = {
+type CompileProgramMetadata = {
     retryErrors: Array<{
         fn: BabelFn;
         error: CompilerError;
     }>;
     inferredEffectLocations: Set<t.SourceLocation>;
 };
-declare function compileProgram(program: NodePath$1<t.Program>, pass: CompilerPass): CompileProgramResult | null;
+declare function compileProgram(program: NodePath$1<t.Program>, pass: CompilerPass): CompileProgramMetadata | null;
+
+type SuppressionRange = {
+    disableComment: t.Comment;
+    enableComment: t.Comment | null;
+    source: SuppressionSource;
+};
+type SuppressionSource = 'Eslint' | 'Flow';
+
+type ProgramContextOptions = {
+    program: NodePath$1<t.Program>;
+    suppressions: Array<SuppressionRange>;
+    opts: PluginOptions;
+    filename: string | null;
+    code: string | null;
+    hasModuleScopeOptOut: boolean;
+};
+declare class ProgramContext {
+    scope: Scope;
+    opts: PluginOptions;
+    filename: string | null;
+    code: string | null;
+    reactRuntimeModule: string;
+    suppressions: Array<SuppressionRange>;
+    hasModuleScopeOptOut: boolean;
+    alreadyCompiled: WeakSet<object> | Set<object>;
+    knownReferencedNames: Set<string>;
+    imports: Map<string, Map<string, NonLocalImportSpecifier>>;
+    retryErrors: Array<{
+        fn: BabelFn;
+        error: CompilerError;
+    }>;
+    inferredEffectLocations: Set<t.SourceLocation>;
+    constructor({ program, suppressions, opts, filename, code, hasModuleScopeOptOut, }: ProgramContextOptions);
+    isHookName(name: string): boolean;
+    hasReference(name: string): boolean;
+    newUid(name: string): string;
+    addMemoCacheImport(): NonLocalImportSpecifier;
+    addImportSpecifier({ source: module, importSpecifierName: specifier }: ExternalFunction, nameHint?: string): NonLocalImportSpecifier;
+    addNewReference(name: string): void;
+    assertGlobalBinding(name: string, localScope?: Scope): Result<void, CompilerError>;
+    logEvent(event: LoggerEvent): void;
+}
 
 declare function runBabelPluginReactCompiler(text: string, file: string, language: 'flow' | 'typescript', options: Partial<PluginOptions> | null, includeAst?: boolean): BabelCore.BabelFileResult;
 
+declare function parseConfigPragmaForTests(pragma: string, defaults: {
+    compilationMode: CompilationMode;
+    environment?: PartialEnvironmentConfig;
+}): PluginOptions;
+declare function parseConfigPragmaAsString(pragma: string): string;
+
 declare function BabelPluginReactCompiler(_babel: typeof BabelCore): BabelCore.PluginObj;
 
 declare global {
     let __DEV__: boolean | null | undefined;
 }
 
-export { CompilerError, CompilerErrorDetail, type CompilerErrorDetailOptions, type CompilerPipelineValue, CompilerSuggestionOperation, Effect, type EnvironmentConfig, ErrorSeverity, type ExternalFunction, type Hook, type Logger, type LoggerEvent, OPT_IN_DIRECTIVES, OPT_OUT_DIRECTIVES, type PluginOptions, ProgramContext, type SourceLocation, ValueKind, compileFn as compile, compileProgram, BabelPluginReactCompiler as default, findDirectiveDisablingMemoization, findDirectiveEnablingMemoization, parseConfigPragmaForTests, parsePluginOptions, printFunctionWithOutlined, printHIR, printReactiveFunction, printReactiveFunctionWithOutlined, runBabelPluginReactCompiler, validateEnvironmentConfig };
+export { CompilerDiagnostic, type CompilerDiagnosticDetail, type CompilerDiagnosticOptions, CompilerError, CompilerErrorDetail, type CompilerErrorDetailOptions, type CompilerPipelineValue, CompilerSuggestionOperation, Effect, type EnvironmentConfig, ErrorSeverity, type ExternalFunction, type Hook, type LintRule, LintRules, type Logger, type LoggerEvent, OPT_IN_DIRECTIVES, OPT_OUT_DIRECTIVES, type PluginOptions, ProgramContext, type SourceLocation, ValueKind, ValueReason, compileFn as compile, compileProgram, BabelPluginReactCompiler as default, findDirectiveDisablingMemoization, tryFindDirectiveEnablingMemoization as findDirectiveEnablingMemoization, parseConfigPragmaAsString, parseConfigPragmaForTests, parsePluginOptions, printFunctionWithOutlined, printHIR, printReactiveFunction, printReactiveFunctionWithOutlined, runBabelPluginReactCompiler, validateEnvironmentConfig };