@openrewrite/recipes-react 0.2.9

package/src/react18/upgrade-to-react-18.ts

@@ -0,0 +1,33 @@
+import {Recipe} from "@openrewrite/rewrite";
+import {UpgradeToReact17} from "../react17/upgrade-to-react-17";
+import {ReplaceReactDomRender} from "./replace-reactdom-render";
+import {RemoveUnstableBatchedUpdates} from "./remove-unstable-batched-updates";
+import {ReplaceUnmountComponentAtNode} from "./replace-unmount-component-at-node";
+import {ReplaceRenderCallback} from "./replace-render-callback";
+
+/**
+ * Composite recipe that applies all React 18 migration recipes.
+ *
+ * First applies all React 17 migrations, then:
+ * - Replace `ReactDOM.render()` with `createRoot().render()`
+ * - Remove `unstable_batchedUpdates` wrappers (React 18 auto-batches)
+ * - Replace `unmountComponentAtNode` with `createRoot().unmount()`
+ * - Remove render callback (3rd argument to `ReactDOM.render`)
+ *
+ * @see https://react.dev/blog/2022/03/08/react-18-upgrade-guide
+ */
+export class UpgradeToReact18 extends Recipe {
+    readonly name = "org.openrewrite.react.migrate.upgrade-to-react-18";
+    readonly displayName = "Upgrade to React 18";
+    readonly description = "Migrate deprecated APIs for React 18 compatibility. Includes all React 16 and 17 migrations plus the createRoot API migration, removal of unstable_batchedUpdates, unmountComponentAtNode replacement, and render callback removal.";
+
+    async recipeList(): Promise<Recipe[]> {
+        return [
+            new UpgradeToReact17(),
+            new ReplaceReactDomRender(),
+            new RemoveUnstableBatchedUpdates(),
+            new ReplaceUnmountComponentAtNode(),
+            new ReplaceRenderCallback(),
+        ];
+    }
+}

package/src/react19/deprecated-react-types.ts

@@ -0,0 +1,120 @@
+import {ExecutionContext, Recipe, TreeVisitor} from "@openrewrite/rewrite";
+import {JavaScriptVisitor, JS} from "@openrewrite/rewrite/javascript";
+import {isIdentifier, J} from "@openrewrite/rewrite/java";
+import {create} from "mutative";
+
+const typeRenames: Record<string, string> = {
+    'SFC': 'FC',
+    'StatelessComponent': 'FunctionComponent',
+    'VFC': 'FC',
+    'VoidFunctionComponent': 'FunctionComponent',
+};
+
+/**
+ * Replaces deprecated React TypeScript types with their modern equivalents.
+ *
+ * In React 19, several TypeScript types have been removed:
+ * - `SFC` → `FC`
+ * - `StatelessComponent` → `FunctionComponent`
+ * - `VFC` → `FC`
+ * - `VoidFunctionComponent` → `FunctionComponent`
+ *
+ * @see https://react.dev/blog/2024/04/25/react-19-upgrade-guide#removed-deprecated-typescript-types
+ */
+export class DeprecatedReactTypes extends Recipe {
+    readonly name = "org.openrewrite.react.19.deprecated-react-types";
+    readonly displayName: string = "Replace deprecated React types";
+    readonly description: string = "Replaces deprecated React TypeScript types (`SFC`, `StatelessComponent`, `VFC`, `VoidFunctionComponent`) with their modern equivalents.";
+
+    async editor(): Promise<TreeVisitor<any, ExecutionContext>> {
+        return new class extends JavaScriptVisitor<ExecutionContext> {
+            private deprecatedNames = new Set<string>();
+
+            override async visitJsCompilationUnit(cu: JS.CompilationUnit, ctx: ExecutionContext): Promise<J | undefined> {
+                this.deprecatedNames.clear();
+
+                // First pass: scan imports to find deprecated React types
+                for (const stmt of cu.statements) {
+                    const s = stmt.element;
+                    if (!s || s.kind !== JS.Kind.Import) continue;
+
+                    const imp = s as JS.Import;
+                    const modulePath = this.getModuleSpecifier(imp);
+                    if (modulePath !== 'react') continue;
+
+                    // Check named imports for deprecated types
+                    if (imp.importClause?.namedBindings) {
+                        const namedImports = imp.importClause.namedBindings as any;
+                        const jContainer = namedImports.elements;
+                        const elements = jContainer?.elements ?? [];
+                        for (const specPadded of elements) {
+                            const spec = specPadded.element ?? specPadded;
+                            if (spec.kind === JS.Kind.ImportSpecifier) {
+                                const importedName = this.getImportedName(spec as JS.ImportSpecifier);
+                                if (importedName && typeRenames[importedName]) {
+                                    this.deprecatedNames.add(importedName);
+                                }
+                            }
+                        }
+                    }
+                }
+
+                if (this.deprecatedNames.size === 0) {
+                    return cu;
+                }
+
+                return super.visitJsCompilationUnit(cu, ctx);
+            }
+
+            override async visitIdentifier(identifier: J.Identifier, ctx: ExecutionContext): Promise<J | undefined> {
+                const id = await super.visitIdentifier(identifier, ctx) as J.Identifier;
+                return this.renameIfDeprecated(id);
+            }
+
+            override async visitParameterizedType(type: J.ParameterizedType, ctx: ExecutionContext): Promise<J | undefined> {
+                let pt = await super.visitParameterizedType(type, ctx) as J.ParameterizedType;
+                if (isIdentifier(pt.class)) {
+                    const renamed = this.renameIfDeprecated(pt.class);
+                    if (renamed !== pt.class) {
+                        return create(pt, draft => {
+                            (draft as any).class = renamed;
+                        });
+                    }
+                }
+                return pt;
+            }
+
+            private renameIfDeprecated(id: J.Identifier): J.Identifier {
+                const name = id.simpleName;
+                if (this.deprecatedNames.has(name) && typeRenames[name]) {
+                    return create(id, draft => {
+                        draft.simpleName = typeRenames[name];
+                    });
+                }
+                return id;
+            }
+
+            private getModuleSpecifier(imp: JS.Import): string {
+                const modSpec = (imp.moduleSpecifier as any).element ?? imp.moduleSpecifier;
+                if (modSpec.kind === J.Kind.Literal) {
+                    return (modSpec as J.Literal).value as string;
+                }
+                return '';
+            }
+
+            private getImportedName(spec: JS.ImportSpecifier): string | undefined {
+                const specifier = spec.specifier;
+                if (specifier.kind === JS.Kind.Alias) {
+                    const alias = specifier as JS.Alias;
+                    const propName = alias.propertyName.element;
+                    if (isIdentifier(propName)) {
+                        return propName.simpleName;
+                    }
+                } else if (isIdentifier(specifier)) {
+                    return specifier.simpleName;
+                }
+                return undefined;
+            }
+        }();
+    }
+}

package/src/react19/find-context-consumer.ts

@@ -0,0 +1,127 @@
+import {Column, DataTable, ExecutionContext, foundSearchResult, Recipe, TreeVisitor} from "@openrewrite/rewrite";
+import {JavaScriptVisitor, JS, JSX} from "@openrewrite/rewrite/javascript";
+import {isIdentifier, J} from "@openrewrite/rewrite/java";
+
+class ContextConsumerRow {
+    @Column({displayName: "File path", description: "The file path where Context.Consumer is used"})
+    filePath!: string;
+
+    @Column({displayName: "Context name", description: "The name of the Context being consumed"})
+    contextName!: string;
+
+    @Column({displayName: "Component name", description: "The enclosing component or function name"})
+    componentName!: string;
+}
+
+/**
+ * Finds usage of the deprecated `<Context.Consumer>` pattern.
+ *
+ * In React 19, `Context.Consumer` is deprecated in favor of the
+ * `use()` hook for reading context in function components.
+ *
+ * Detects:
+ * - `<ThemeContext.Consumer>` JSX elements
+ * - `<SomeContext.Consumer>` with any context name
+ *
+ * Before:
+ * ```tsx
+ * <ThemeContext.Consumer>
+ *   {theme => <div className={theme}>Hello</div>}
+ * </ThemeContext.Consumer>
+ * ```
+ *
+ * Recommended replacement:
+ * ```tsx
+ * import { use } from 'react';
+ * const theme = use(ThemeContext);
+ * return <div className={theme}>Hello</div>;
+ * ```
+ *
+ * @see https://react.dev/blog/2024/04/25/react-19-upgrade-guide#context-as-a-provider
+ */
+export class FindContextConsumer extends Recipe {
+    readonly name = "org.openrewrite.react.19.find-context-consumer";
+    readonly displayName = "Find `Context.Consumer` usage";
+    readonly description = "Finds usage of the deprecated `<Context.Consumer>` pattern. In React 19, use the `use()` hook instead.";
+
+    private dataTable = new DataTable<ContextConsumerRow>(
+        "org.openrewrite.react.19.ContextConsumerTable",
+        "Context.Consumer usages",
+        "Table of all Context.Consumer usages found in the codebase.",
+        ContextConsumerRow
+    );
+
+    async editor(): Promise<TreeVisitor<any, ExecutionContext>> {
+        const dataTable = this.dataTable;
+
+        return new class extends JavaScriptVisitor<ExecutionContext> {
+            private filePath = "";
+            private componentStack: string[] = [];
+
+            override async visitJsCompilationUnit(cu: JS.CompilationUnit, ctx: ExecutionContext): Promise<J | undefined> {
+                this.filePath = cu.sourcePath ?? "";
+                this.componentStack = [];
+                return super.visitJsCompilationUnit(cu, ctx);
+            }
+
+            // Track function/component names
+            override async visitMethodDeclaration(method: J.MethodDeclaration, ctx: ExecutionContext): Promise<J | undefined> {
+                const name = method.name?.simpleName ?? "<anonymous>";
+                this.componentStack.push(name);
+                const result = await super.visitMethodDeclaration(method, ctx);
+                this.componentStack.pop();
+                return result;
+            }
+
+            override async visitVariableDeclarations(vd: J.VariableDeclarations, ctx: ExecutionContext): Promise<J | undefined> {
+                const namedVar = vd.variables?.[0]?.element;
+                if (namedVar) {
+                    const name = (namedVar.name as J.Identifier)?.simpleName;
+                    if (name) {
+                        this.componentStack.push(name);
+                        const result = await super.visitVariableDeclarations(vd, ctx);
+                        this.componentStack.pop();
+                        return result;
+                    }
+                }
+                return super.visitVariableDeclarations(vd, ctx);
+            }
+
+            override async visitJsxTag(tag: JSX.Tag, ctx: ExecutionContext): Promise<J | undefined> {
+                let t = await super.visitJsxTag(tag, ctx) as JSX.Tag;
+
+                const openName = t.openName.element;
+
+                // Check if the opening tag is a FieldAccess like Something.Consumer
+                if (openName.kind !== J.Kind.FieldAccess) {
+                    return t;
+                }
+
+                const fieldAccess = openName as J.FieldAccess;
+                const propertyName = fieldAccess.name.element.simpleName;
+
+                if (propertyName !== 'Consumer') {
+                    return t;
+                }
+
+                // Get the context name
+                let contextName = "<unknown>";
+                if (isIdentifier(fieldAccess.target)) {
+                    contextName = (fieldAccess.target as J.Identifier).simpleName;
+                }
+
+                const componentName = this.componentStack.length > 0
+                    ? this.componentStack[this.componentStack.length - 1]
+                    : "<module>";
+
+                dataTable.insertRow(ctx, {
+                    filePath: this.filePath,
+                    contextName,
+                    componentName
+                });
+
+                return foundSearchResult(t, `Deprecated: ${contextName}.Consumer — use the use() hook instead`);
+            }
+        }();
+    }
+}

package/src/react19/find-deprecated-reactdom-apis.ts

@@ -0,0 +1,125 @@
+import {Column, DataTable, ExecutionContext, foundSearchResult, Recipe, TreeVisitor} from "@openrewrite/rewrite";
+import {JavaScriptVisitor, JS} from "@openrewrite/rewrite/javascript";
+import {isIdentifier, J} from "@openrewrite/rewrite/java";
+
+class DeprecatedReactDomRow {
+    @Column({displayName: "File path", description: "The file path where the deprecated API is used"})
+    filePath!: string;
+
+    @Column({displayName: "API name", description: "The name of the deprecated ReactDOM API"})
+    apiName!: string;
+
+    @Column({displayName: "Replacement", description: "The recommended replacement"})
+    replacement!: string;
+}
+
+const DEPRECATED_APIS: Record<string, string> = {
+    'findDOMNode': 'Use refs instead of ReactDOM.findDOMNode()',
+    'unmountComponentAtNode': 'Use root.unmount() from createRoot() instead',
+    'createFactory': 'Use JSX or React.createElement() instead',
+    'renderToNodeStream': 'Use renderToPipeableStream instead',
+    'renderToStaticNodeStream': 'Use renderToReadableStream or renderToPipeableStream instead',
+};
+
+/**
+ * Finds usage of deprecated or removed ReactDOM APIs in React 19.
+ *
+ * Detects:
+ * - `ReactDOM.findDOMNode(component)` — removed, use refs instead
+ * - `ReactDOM.unmountComponentAtNode(container)` — removed, use `root.unmount()`
+ * - `React.createFactory(type)` — removed, use JSX or `createElement`
+ * - `ReactDOMServer.renderToNodeStream()` — removed, use `renderToPipeableStream`
+ * - `ReactDOMServer.renderToStaticNodeStream()` — removed
+ *
+ * Also detects named imports of these functions.
+ *
+ * @see https://react.dev/blog/2024/04/25/react-19-upgrade-guide#removed-deprecated-react-apis
+ */
+export class FindDeprecatedReactDomAPIs extends Recipe {
+    readonly name = "org.openrewrite.react.19.find-deprecated-reactdom-apis";
+    readonly displayName = "Find deprecated ReactDOM APIs";
+    readonly description = "Finds usage of deprecated or removed ReactDOM APIs (`findDOMNode`, `unmountComponentAtNode`, `createFactory`, `renderToNodeStream`) that were removed in React 19.";
+
+    private dataTable = new DataTable<DeprecatedReactDomRow>(
+        "org.openrewrite.react.19.DeprecatedReactDomAPITable",
+        "Deprecated ReactDOM API usages",
+        "Table of all deprecated ReactDOM API usages found in the codebase.",
+        DeprecatedReactDomRow
+    );
+
+    async editor(): Promise<TreeVisitor<any, ExecutionContext>> {
+        const dataTable = this.dataTable;
+
+        return new class extends JavaScriptVisitor<ExecutionContext> {
+            private filePath = "";
+            private importedDeprecatedApis = new Set<string>();
+
+            override async visitJsCompilationUnit(cu: JS.CompilationUnit, ctx: ExecutionContext): Promise<J | undefined> {
+                this.filePath = cu.sourcePath ?? "";
+                this.importedDeprecatedApis.clear();
+                return super.visitJsCompilationUnit(cu, ctx);
+            }
+
+            // Detect imports of deprecated APIs
+            override async visitImportSpecifier(spec: JS.ImportSpecifier, ctx: ExecutionContext): Promise<J | undefined> {
+                const specifier = spec.specifier;
+
+                let importedName: string | undefined;
+                if (specifier.kind === JS.Kind.Alias) {
+                    const alias = specifier as JS.Alias;
+                    const propName = alias.propertyName.element;
+                    if (isIdentifier(propName)) {
+                        importedName = propName.simpleName;
+                    }
+                } else if (isIdentifier(specifier)) {
+                    importedName = specifier.simpleName;
+                }
+
+                if (importedName && DEPRECATED_APIS[importedName]) {
+                    this.importedDeprecatedApis.add(importedName);
+                    dataTable.insertRow(ctx, {
+                        filePath: this.filePath,
+                        apiName: importedName,
+                        replacement: DEPRECATED_APIS[importedName]
+                    });
+                    return foundSearchResult(spec, `Deprecated API: ${importedName}`);
+                }
+
+                return super.visitImportSpecifier(spec, ctx);
+            }
+
+            // Detect method calls: ReactDOM.findDOMNode(), ReactDOM.unmountComponentAtNode(), etc.
+            override async visitMethodInvocation(method: J.MethodInvocation, ctx: ExecutionContext): Promise<J | undefined> {
+                let m = await super.visitMethodInvocation(method, ctx) as J.MethodInvocation;
+
+                const methodName = m.name.simpleName;
+
+                if (!DEPRECATED_APIS[methodName]) return m;
+
+                // Direct call from named import: findDOMNode(...)
+                if (!m.select && this.importedDeprecatedApis.has(methodName)) {
+                    // Already marked at import level, just mark the call too
+                    return foundSearchResult(m, `Deprecated API: ${methodName}`);
+                }
+
+                // Namespace call: ReactDOM.findDOMNode(...), React.createFactory(...)
+                if (m.select) {
+                    const select = (m.select as any).element ?? m.select;
+                    if (isIdentifier(select)) {
+                        const ns = select.simpleName;
+                        if (ns === 'ReactDOM' || ns === 'React' || ns === 'ReactDOMServer') {
+                            dataTable.insertRow(ctx, {
+                                filePath: this.filePath,
+                                apiName: `${ns}.${methodName}`,
+                                replacement: DEPRECATED_APIS[methodName]
+                            });
+                            return foundSearchResult(m, `Deprecated API: ${ns}.${methodName}`);
+                        }
+                    }
+                }
+
+                return m;
+            }
+        }();
+    }
+}

package/src/react19/find-element-ref.ts

@@ -0,0 +1,86 @@
+import {Column, DataTable, ExecutionContext, foundSearchResult, Recipe, TreeVisitor} from "@openrewrite/rewrite";
+import {JavaScriptVisitor, JS} from "@openrewrite/rewrite/javascript";
+import {isIdentifier, J} from "@openrewrite/rewrite/java";
+
+class ElementRefRow {
+    @Column({displayName: "File path", description: "The file path where element.ref is accessed"})
+    filePath!: string;
+
+    @Column({displayName: "Expression", description: "The full expression accessing .ref"})
+    expression!: string;
+}
+
+/**
+ * Finds direct access of `element.ref` on React elements.
+ *
+ * In React 19, `element.ref` is deprecated and will be removed in a future version.
+ * Use `element.props.ref` instead.
+ *
+ * Before:
+ * ```tsx
+ * const ref = element.ref;
+ * ```
+ *
+ * After (manual fix):
+ * ```tsx
+ * const ref = element.props.ref;
+ * ```
+ *
+ * @see https://react.dev/blog/2024/04/25/react-19-upgrade-guide
+ */
+export class FindElementRef extends Recipe {
+    readonly name = "org.openrewrite.react.19.find-element-ref";
+    readonly displayName = "Find `element.ref` access";
+    readonly description = "Finds direct access of `element.ref` on React elements. In React 19, `element.ref` is deprecated; use `element.props.ref` instead.";
+
+    private dataTable = new DataTable<ElementRefRow>(
+        "org.openrewrite.react.19.ElementRefTable",
+        "Element ref access usages",
+        "Table of all element.ref access usages found in the codebase.",
+        ElementRefRow
+    );
+
+    async editor(): Promise<TreeVisitor<any, ExecutionContext>> {
+        const dataTable = this.dataTable;
+
+        return new class extends JavaScriptVisitor<ExecutionContext> {
+            private filePath = "";
+
+            override async visitJsCompilationUnit(cu: JS.CompilationUnit, ctx: ExecutionContext): Promise<J | undefined> {
+                this.filePath = cu.sourcePath ?? "";
+                return super.visitJsCompilationUnit(cu, ctx);
+            }
+
+            override async visitFieldAccess(fieldAccess: J.FieldAccess, ctx: ExecutionContext): Promise<J | undefined> {
+                let fa = await super.visitFieldAccess(fieldAccess, ctx) as J.FieldAccess;
+
+                if (fa.name.element.simpleName !== 'ref') return fa;
+
+                // Exclude this.refs (different issue - string refs)
+                if (isIdentifier(fa.target) && fa.target.simpleName === 'refs') return fa;
+
+                // Exclude props.ref (that's the recommended replacement)
+                if (isIdentifier(fa.target) && fa.target.simpleName === 'props') return fa;
+
+                // Exclude element.props.ref (FieldAccess target with .props name)
+                if (fa.target.kind === J.Kind.FieldAccess) {
+                    const targetFa = fa.target as J.FieldAccess;
+                    if (targetFa.name.element.simpleName === 'props') return fa;
+                }
+
+                // Exclude this.ref (not a React element pattern)
+                if (fa.target.kind === J.Kind.Identifier && (fa.target as J.Identifier).simpleName === 'this') return fa;
+
+                // This is element.ref access - mark it
+                const targetName = isIdentifier(fa.target) ? fa.target.simpleName : '(expression)';
+
+                dataTable.insertRow(ctx, {
+                    filePath: this.filePath,
+                    expression: `${targetName}.ref`
+                });
+
+                return foundSearchResult(fa, "element.ref is deprecated, use element.props.ref");
+            }
+        }();
+    }
+}

package/src/react19/find-legacy-context-api.ts

@@ -0,0 +1,157 @@
+import {Column, DataTable, ExecutionContext, foundSearchResult, Recipe, TreeVisitor} from "@openrewrite/rewrite";
+import {JavaScriptVisitor, JS} from "@openrewrite/rewrite/javascript";
+import {isIdentifier, J} from "@openrewrite/rewrite/java";
+
+class LegacyContextRow {
+    @Column({displayName: "File path", description: "The file path where the legacy context API is used"})
+    filePath!: string;
+
+    @Column({displayName: "API type", description: "The type of legacy context API: contextTypes, childContextTypes, or getChildContext"})
+    apiType!: string;
+
+    @Column({displayName: "Component name", description: "The name of the component using the legacy context API"})
+    componentName!: string;
+}
+
+/**
+ * Finds usage of the legacy Context API that was removed in React 19.
+ *
+ * Detects:
+ * - `static contextTypes = { ... }` in class components
+ * - `Component.contextTypes = { ... }` static assignments
+ * - `static childContextTypes = { ... }` in class components
+ * - `Component.childContextTypes = { ... }` static assignments
+ * - `getChildContext()` method definitions in class components
+ *
+ * These should be migrated to `React.createContext()` with the
+ * `<Context.Provider>` / `useContext()` API.
+ *
+ * @see https://react.dev/blog/2024/04/25/react-19-upgrade-guide#removed-legacy-context
+ */
+export class FindLegacyContextAPI extends Recipe {
+    readonly name = "org.openrewrite.react.19.find-legacy-context-api";
+    readonly displayName = "Find legacy Context API usage";
+    readonly description = "Finds usage of the legacy Context API (`contextTypes`, `childContextTypes`, `getChildContext`) that was removed in React 19. These must be migrated to `React.createContext()`.";
+
+    private dataTable = new DataTable<LegacyContextRow>(
+        "org.openrewrite.react.19.LegacyContextAPITable",
+        "Legacy Context API usages",
+        "Table of all legacy Context API usages found in the codebase.",
+        LegacyContextRow
+    );
+
+    async editor(): Promise<TreeVisitor<any, ExecutionContext>> {
+        const dataTable = this.dataTable;
+        const LEGACY_CONTEXT_PROPS = new Set(['contextTypes', 'childContextTypes']);
+
+        return new class extends JavaScriptVisitor<ExecutionContext> {
+            private filePath = "";
+            private classStack: string[] = [];
+
+            override async visitJsCompilationUnit(cu: JS.CompilationUnit, ctx: ExecutionContext): Promise<J | undefined> {
+                this.filePath = cu.sourcePath ?? "";
+                this.classStack = [];
+
+                let result = await super.visitJsCompilationUnit(cu, ctx) as JS.CompilationUnit;
+
+                // Check top-level static assignments: Component.contextTypes = { ... }
+                for (const paddedStmt of result.statements) {
+                    const stmt = paddedStmt.element;
+                    if (!stmt) continue;
+
+                    let assignment: J.Assignment | undefined;
+
+                    if (stmt.kind === JS.Kind.ExpressionStatement) {
+                        const exprStmt = stmt as JS.ExpressionStatement;
+                        if (exprStmt.expression.kind === J.Kind.Assignment) {
+                            assignment = exprStmt.expression as J.Assignment;
+                        }
+                    } else if (stmt.kind === J.Kind.Assignment) {
+                        assignment = stmt as J.Assignment;
+                    }
+
+                    if (!assignment) continue;
+                    if (assignment.variable.kind !== J.Kind.FieldAccess) continue;
+
+                    const fa = assignment.variable as J.FieldAccess;
+                    const propName = fa.name.element.simpleName;
+
+                    if (!LEGACY_CONTEXT_PROPS.has(propName)) continue;
+                    if (!isIdentifier(fa.target)) continue;
+
+                    const componentName = (fa.target as J.Identifier).simpleName;
+                    dataTable.insertRow(ctx, {
+                        filePath: this.filePath,
+                        apiType: propName,
+                        componentName
+                    });
+                    // Mark the assignment as a search result
+                    result = {
+                        ...result,
+                        statements: result.statements.map(s => {
+                            if (s === paddedStmt) {
+                                return {
+                                    ...s,
+                                    element: foundSearchResult(stmt, `Legacy Context API: ${propName}`)
+                                };
+                            }
+                            return s;
+                        })
+                    } as any;
+                }
+
+                return result;
+            }
+
+            override async visitClassDeclaration(classDecl: J.ClassDeclaration, ctx: ExecutionContext): Promise<J | undefined> {
+                const name = classDecl.name?.simpleName ?? "<anonymous>";
+                this.classStack.push(name);
+                const result = await super.visitClassDeclaration(classDecl, ctx);
+                this.classStack.pop();
+                return result;
+            }
+
+            // Detect static contextTypes / childContextTypes in class bodies
+            override async visitVariableDeclarations(vd: J.VariableDeclarations, ctx: ExecutionContext): Promise<J | undefined> {
+                const result = await super.visitVariableDeclarations(vd, ctx) as J.VariableDeclarations;
+
+                if (this.classStack.length === 0) return result;
+
+                // Check for static contextTypes or childContextTypes
+                const namedVar = vd.variables?.[0]?.element;
+                if (!namedVar) return result;
+
+                const varName = (namedVar.name as J.Identifier)?.simpleName;
+                if (!varName || !LEGACY_CONTEXT_PROPS.has(varName)) return result;
+
+                const componentName = this.classStack[this.classStack.length - 1];
+                dataTable.insertRow(ctx, {
+                    filePath: this.filePath,
+                    apiType: varName,
+                    componentName
+                });
+
+                return foundSearchResult(result, `Legacy Context API: ${varName}`);
+            }
+
+            // Detect getChildContext() method definitions
+            override async visitMethodDeclaration(method: J.MethodDeclaration, ctx: ExecutionContext): Promise<J | undefined> {
+                const result = await super.visitMethodDeclaration(method, ctx) as J.MethodDeclaration;
+
+                if (this.classStack.length === 0) return result;
+
+                const methodName = method.name?.simpleName;
+                if (methodName !== 'getChildContext') return result;
+
+                const componentName = this.classStack[this.classStack.length - 1];
+                dataTable.insertRow(ctx, {
+                    filePath: this.filePath,
+                    apiType: 'getChildContext',
+                    componentName
+                });
+
+                return foundSearchResult(result, "Legacy Context API: getChildContext");
+            }
+        }();
+    }
+}