All @openrewrite/rewrite modules must only be loaded once (#6131)

The complexity exists because we're working around a fundamental limitation of Node.js's module system. Here's why each part is necessary:

What the code does:

1. Iterates all cached modules - No way around this; we need to find what's already loaded
2. Converts filesystem paths → module specifiers - This is the "complex" part, but it's unavoidable
3. Maps cache entries - Simple once we have the paths

The path conversion complexity is unavoidable because:

- require.cache keys: `/absolute/path/node_modules/@openrewrite/rewrite/dist/tree.js`
- Module imports: `require('@openrewrite/rewrite/tree')`
- We must reverse-engineer one from the other

Author: knutwannheden

rewrite-javascript/rewrite/src/javascript/preconditions.ts

@@ -27,15 +27,15 @@ export function hasSourcePath(filePattern: string): Promise<RpcRecipe> | TreeVis
 }
 
 export function usesMethod(methodPattern: string, matchOverrides: boolean = false): Promise<RpcRecipe> | TreeVisitor<any, ExecutionContext> {
-    return RewriteRpc.get() ? RewriteRpc.get()!.prepareRecipe("org.openrewrite.java.search.UsesMethod", {
+    return RewriteRpc.get() ? RewriteRpc.get()!.prepareRecipe("org.openrewrite.java.search.FindMethods", {
         methodPattern,
         matchOverrides
     }) : new UsesMethod(methodPattern);
 }
 
 export function usesType(fullyQualifiedType: string): Promise<RpcRecipe> | TreeVisitor<any, ExecutionContext> {
-    return RewriteRpc.get() ? RewriteRpc.get()!.prepareRecipe("org.openrewrite.java.search.UsesType", {
+    return RewriteRpc.get() ? RewriteRpc.get()!.prepareRecipe("org.openrewrite.java.search.FindTypes", {
         fullyQualifiedType,
-        includeImplicit: false
+        checkAssignability: false
     }) : new UsesType(fullyQualifiedType);
 }

rewrite-javascript/rewrite/src/rpc/request/install-recipes.ts

@@ -142,28 +142,39 @@ export class InstallRecipes {
     }
 }
 
+/**
+ * Ensures dynamically loaded modules share the same class instances as the host
+ * by mapping require.cache entries. This prevents instanceof failures when the
+ * same package is installed in multiple node_modules directories.
+ */
 function setupSharedDependencies(targetModulePath: string) {
-    const sharedDeps = [
-        '@openrewrite/rewrite',
-        'vscode-jsonrpc',
-    ];
-
-    sharedDeps.forEach(dep => {
-        try {
-            // Get your already-loaded version
-            const yourDepPath = require.resolve(dep);
-            const yourModule = require.cache[yourDepPath];
-
-            if (yourModule) {
-                // Find where the target would look for this dependency
-                const targetDir = path.dirname(targetModulePath);
-                const targetDepPath = require.resolve(dep, {paths: [targetDir]});
-
-                // Make the target use your cached version
-                require.cache[targetDepPath] = yourModule;
+    const sharedDeps = ['@openrewrite/rewrite', 'vscode-jsonrpc'];
+    const targetDir = path.dirname(targetModulePath);
+
+    sharedDeps.forEach(depName => {
+        const depPattern = path.sep + 'node_modules' + path.sep + depName.replace('/', path.sep);
+
+        for (const cachedPath of Object.keys(require.cache)) {
+            if (!cachedPath.includes(depPattern)) continue;
+
+            try {
+                // Extract subpath: /path/node_modules/@pkg/dist/tree.js -> dist/tree.js
+                const pkgIndex = cachedPath.indexOf(depPattern);
+                let subpath = cachedPath.substring(pkgIndex + depPattern.length)
+                    .replace(/^[/\\]/, '')           // Remove leading slash
+                    .replace(/\.(js|ts)$/, '')        // Remove extension
+                    .replace(/^dist[/\\]/, '')        // Remove dist/ prefix if present
+                    .replace(/[/\\]index$/, '');      // Remove /index suffix
+
+                // Build require path: @pkg or @pkg/subpath
+                const requirePath = subpath ? `${depName}/${subpath}` : depName;
+
+                // Resolve from target's perspective and map cache
+                const targetDepPath = require.resolve(requirePath, {paths: [targetDir]});
+                require.cache[targetDepPath] = require.cache[cachedPath];
+            } catch (e) {
+                // Target can't resolve this path, skip
             }
-        } catch (e) {
-            // Module not found or not resolvable, skip
         }
     });
 }

rewrite-javascript/rewrite/test/rpc/shared-dependencies.test.ts

@@ -0,0 +1,94 @@
+/*
+ * Copyright 2025 the original author or authors.
+ * <p>
+ * Licensed under the Moderne Source Available License (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * <p>
+ * https://docs.moderne.io/licensing/moderne-source-available-license
+ * <p>
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import * as path from 'path';
+
+describe('Shared dependencies setup', () => {
+    let originalCache: any;
+
+    beforeEach(() => {
+        // Save original require.cache
+        originalCache = {...require.cache};
+    });
+
+    afterEach(() => {
+        // Restore original require.cache
+        Object.keys(require.cache).forEach(key => {
+            if (!originalCache[key]) {
+                delete require.cache[key];
+            }
+        });
+    });
+
+    it('should map all subpaths of shared dependencies', () => {
+        // This test verifies the logic of mapping multiple cached modules
+        // In a real scenario, dynamically loaded recipes would benefit from this
+
+        // Simulate what happens when modules are cached
+        const mockCache: Record<string, any> = {
+            '/some/path/node_modules/@openrewrite/rewrite/tree.js': {exports: {}},
+            '/some/path/node_modules/@openrewrite/rewrite/recipe.js': {exports: {}},
+            '/some/path/node_modules/@openrewrite/rewrite/visitor.js': {exports: {}},
+        };
+
+        // Count modules from our mock that match the pattern
+        const depPattern = path.sep + 'node_modules' + path.sep + '@openrewrite/rewrite'.replace('/', path.sep);
+        const rewriteModules = Object.keys(mockCache).filter(p => p.includes(depPattern));
+
+        // Should find all three mocked modules
+        expect(rewriteModules.length).toBe(3);
+
+        // Verify different subpaths exist
+        const hasTreeModule = rewriteModules.some(p => p.includes(path.sep + 'tree'));
+        const hasRecipeModule = rewriteModules.some(p => p.includes(path.sep + 'recipe'));
+        const hasVisitorModule = rewriteModules.some(p => p.includes(path.sep + 'visitor'));
+
+        expect(hasTreeModule).toBe(true);
+        expect(hasRecipeModule).toBe(true);
+        expect(hasVisitorModule).toBe(true);
+    });
+
+    it('should handle package names with slashes correctly', () => {
+        const depPattern = path.sep + 'node_modules' + path.sep + '@openrewrite/rewrite'.replace('/', path.sep);
+
+        // Pattern should work correctly with scoped packages
+        expect(depPattern).toContain('@openrewrite' + path.sep + 'rewrite');
+    });
+
+    it('should extract subpaths correctly', () => {
+        const testCases = [
+            {
+                path: '/path/to/node_modules/@openrewrite/rewrite/tree.js',
+                expected: '/tree.js'
+            },
+            {
+                path: '/path/to/node_modules/@openrewrite/rewrite/index.js',
+                expected: '/index.js'
+            },
+            {
+                path: '/path/to/node_modules/@openrewrite/rewrite/rpc/recipe.js',
+                expected: '/rpc/recipe.js'
+            }
+        ];
+
+        testCases.forEach(tc => {
+            const depPattern = path.sep + 'node_modules' + path.sep + '@openrewrite/rewrite'.replace('/', path.sep);
+            const packageIndex = tc.path.indexOf(depPattern);
+            const afterPackage = tc.path.substring(packageIndex + depPattern.length);
+
+            expect(afterPackage).toBe(tc.expected);
+        });
+    });
+});