@openrewrite/rewrite 8.62.4 → 8.62.6

package/src/javascript/rpc.ts

@@ -105,7 +105,7 @@ class JavaScriptSender extends JavaScriptVisitor<RpcSendQueue> {
         await q.getAndSend(functionCall, m => m.function, f => this.visitRightPadded(f, q));
         await q.getAndSend(functionCall, m => m.typeParameters, params => this.visitContainer(params, q));
         await q.getAndSend(functionCall, m => m.arguments, args => this.visitContainer(args, q));
-        await q.getAndSend(functionCall, m => asRef(m.functionType), type => this.visitType(type, q));
+        await q.getAndSend(functionCall, m => asRef(m.methodType), type => this.visitType(type, q));
         return functionCall;
     }
 
@@ -643,7 +643,7 @@ class JavaScriptReceiver extends JavaScriptVisitor<RpcReceiveQueue> {
         draft.function = await q.receive(functionCall.function, select => this.visitRightPadded(select, q));
         draft.typeParameters = await q.receive(functionCall.typeParameters, typeParams => this.visitContainer(typeParams, q));
         draft.arguments = await q.receive(functionCall.arguments, args => this.visitContainer(args, q));
-        draft.functionType = await q.receive(functionCall.functionType, type => this.visitType(type, q) as unknown as Type.Method);
+        draft.methodType = await q.receive(functionCall.methodType, type => this.visitType(type, q) as unknown as Type.Method);
 
         return finishDraft(draft);
     }

package/src/javascript/search/index.ts

@@ -0,0 +1,2 @@
+export * from './uses-method';
+export * from './uses-type';

package/src/javascript/search/uses-method.ts

@@ -0,0 +1,21 @@
+import {Expression, J, JavaVisitor} from "../../java";
+import {ExecutionContext} from "../../execution";
+import {MethodMatcher} from "../method-matcher";
+import {JS} from "../tree";
+import {foundSearchResult} from "../../markers";
+
+export class UsesMethod extends JavaVisitor<ExecutionContext> {
+    private readonly matcher;
+
+    constructor(pattern: string) {
+        super();
+        this.matcher = new MethodMatcher(pattern);
+    }
+
+    protected async visitExpression(expression: Expression, p: ExecutionContext): Promise<J | undefined> {
+        if (JS.isMethodCall(expression) && this.matcher.matches(expression.methodType)) {
+            return foundSearchResult(expression);
+        }
+        return super.visitExpression(expression, p);
+    }
+}

package/src/javascript/search/uses-type.ts

@@ -0,0 +1,27 @@
+import {J, JavaVisitor, Type} from "../../java";
+import {ExecutionContext} from "../../execution";
+import * as picomatch from "picomatch";
+import {foundSearchResult} from "../../markers";
+
+export class UsesType extends JavaVisitor<ExecutionContext> {
+    private readonly matcher: picomatch.Matcher;
+
+    constructor(typePattern: string) {
+        super();
+        // Create a picomatch matcher for the pattern
+        this.matcher = picomatch.default ? picomatch.default(typePattern) : (picomatch as any)(typePattern);
+    }
+
+    protected async preVisit(tree: J, _: ExecutionContext): Promise<J | undefined> {
+        if (J.hasType(tree)) {
+            const type = tree.type;
+            if (Type.isFullyQualified(type)) {
+                const fullyQualifiedName = Type.FullyQualified.getFullyQualifiedName(type);
+                if (this.matcher(fullyQualifiedName)) {
+                    return foundSearchResult(tree);
+                }
+            }
+        }
+        return tree;
+    }
+}

package/src/javascript/templating.ts

@@ -92,7 +92,8 @@ export class Pattern {
 export class MatchResult implements Pick<Map<string, J>, "get"> {
     constructor(
         private readonly bindings: Map<string, J> = new Map()
-    ) {}
+    ) {
+    }
 
     get(capture: Capture | string): J | undefined {
         const name = typeof capture === "string" ? capture : capture.name;
@@ -577,7 +578,7 @@ class TemplateApplier {
      * @returns A Promise resolving to the modified AST
      */
     async apply(): Promise<J | undefined> {
-        const {tree, loc, mode} = this.coordinates;
+        const {loc} = this.coordinates;
 
         // Apply the template based on the location and mode
         switch (loc || 'EXPRESSION_PREFIX') {
@@ -771,7 +772,7 @@ class RewriteRuleImpl implements RewriteRule {
  *     after: template`${"left"} === ${"right"}`
  * }));
  */
-export function rewrite<T extends J>(
+export function rewrite(
     builderFn: () => RewriteConfig
 ): RewriteRule {
     const config = builderFn();

package/src/javascript/tree.ts

@@ -17,7 +17,20 @@
  */
 
 import {SourceFile} from "../tree";
-import {Expression, J, NameTree, Statement, Type, TypedTree, TypeTree, VariableDeclarator,} from "../java";
+import {
+    Expression,
+    J,
+    JavaVisitor,
+    MethodCall,
+    NameTree,
+    Statement,
+    Type,
+    TypedTree,
+    TypeTree,
+    VariableDeclarator,
+    registerJavaExtensionKinds
+} from "../java";
+import {JavaScriptVisitor} from "./visitor";
 
 export interface JS extends J {
 }
@@ -94,6 +107,10 @@ export namespace JS {
         WithStatement: "org.openrewrite.javascript.tree.JS$WithStatement",
     } as const;
 
+    export function isMethodCall(e?: Expression): e is MethodCall {
+        return J.isMethodCall(e) || e?.kind === JS.Kind.FunctionCall;
+    }
+
     /**
      * Represents the root of a JavaScript AST (compilation unit).
      * @example // file.js as AST root
@@ -650,12 +667,11 @@ export namespace JS {
      * @example data["key"](5, 0, 4)
      * @example (() => { return 3 + 5 })()
      */
-    export interface FunctionCall extends JS, Expression {
+    export interface FunctionCall extends JS, MethodCall {
         readonly kind: typeof Kind.FunctionCall;
         readonly function?: J.RightPadded<Expression>;
         readonly typeParameters?: J.Container<Expression>;
         readonly arguments: J.Container<Expression>;
-        readonly functionType?: Type.Method;
     }
 
     /**
@@ -901,6 +917,34 @@ export namespace JSX {
 
 const KindValues = new Set(Object.values(JS.Kind));
 
+function javascriptVisitorAdapter<P>(visitor: JavaVisitor<P>): JavaVisitor<P> {
+    const adaptedVisitor = new JavaScriptVisitor<P>();
+
+    // Walk up the prototype chain of the visitor to get all overridden methods
+    let proto = Object.getPrototypeOf(visitor);
+    while (proto && proto !== JavaVisitor.prototype) {
+        Object.getOwnPropertyNames(proto).forEach(name => {
+            const descriptor = Object.getOwnPropertyDescriptor(proto, name);
+            if (descriptor && typeof descriptor.value === 'function' && name !== 'constructor') {
+                // Copy the method, binding it to jsVisitor
+                (adaptedVisitor as any)[name] = descriptor.value.bind(adaptedVisitor);
+            }
+        });
+        proto = Object.getPrototypeOf(proto);
+    }
+
+    // Also copy any instance properties
+    Object.keys(visitor).forEach(key => {
+        if (!(key in adaptedVisitor)) {
+            (adaptedVisitor as any)[key] = (visitor as any)[key];
+        }
+    });
+
+    return adaptedVisitor;
+}
+
+registerJavaExtensionKinds(Object.values(JS.Kind), javascriptVisitorAdapter);
+
 export function isJavaScript(tree: any): tree is JS {
     return KindValues.has(tree["kind"]);
 }

package/src/javascript/type-mapping.ts

@@ -22,13 +22,6 @@ class NonDraftableType {
     [immerable] = false;
 }
 
-const builtInTypes = new Set([
-    'Array', 'Object', 'Function', 'String', 'Number', 'Boolean',
-    'Date', 'RegExp', 'Error', 'Promise', 'Map', 'Set', 'WeakMap',
-    'WeakSet', 'Symbol', 'BigInt', 'HTMLElement', 'Document',
-    'Window', 'Console', 'JSON', 'Math', 'Reflect', 'Proxy'
-]);
-
 export class JavaScriptTypeMapping {
     private readonly typeCache: Map<string | number, Type> = new Map();
     private readonly regExpSymbol: ts.Symbol | undefined;
@@ -121,7 +114,7 @@ export class JavaScriptTypeMapping {
 
     primitiveType(node: ts.Node): Type.Primitive {
         const type = this.type(node);
-        if (Type.isClass(type) && type.fullyQualifiedName === 'lib.RegExp') {
+        if (Type.isClass(type) && type.fullyQualifiedName === 'RegExp') {
             return Type.Primitive.String;
         }
         return Type.isPrimitive(type) ? type : Type.Primitive.None;
@@ -139,7 +132,47 @@ export class JavaScriptTypeMapping {
         return undefined;
     }
 
+    /**
+     * Helper to create a Type.Method object from common parameters
+     */
+    private createMethodType(
+        signature: ts.Signature,
+        node: ts.Node,
+        declaringType: Type.FullyQualified,
+        name: string,
+        declaredFormalTypeNames: string[] = []
+    ): Type.Method {
+        const returnType = signature.getReturnType();
+        const parameters = signature.getParameters();
+        const parameterTypes: Type[] = [];
+        const parameterNames: string[] = [];
+
+        for (const param of parameters) {
+            parameterNames.push(param.getName());
+            const paramType = this.checker.getTypeOfSymbolAtLocation(param, node);
+            parameterTypes.push(this.getType(paramType));
+        }
+
+        // Create the Type.Method object
+        return Object.assign(new NonDraftableType(), {
+            kind: Type.Kind.Method,
+            declaringType: declaringType,
+            name: name,
+            returnType: this.getType(returnType),
+            parameterNames: parameterNames,
+            parameterTypes: parameterTypes,
+            thrownExceptions: [], // JavaScript doesn't have checked exceptions
+            annotations: [],
+            defaultValue: undefined,
+            declaredFormalTypeNames: declaredFormalTypeNames,
+            toJSON: function () {
+                return Type.signature(this);
+            }
+        }) as Type.Method;
+    }
+
     methodType(node: ts.Node): Type.Method | undefined {
+
         let signature: ts.Signature | undefined;
         let methodName: string;
         let declaringType: Type.FullyQualified;
@@ -153,7 +186,68 @@ export class JavaScriptTypeMapping {
                 return undefined;
             }
 
-            const symbol = this.checker.getSymbolAtLocation(node.expression);
+            let symbol = this.checker.getSymbolAtLocation(node.expression);
+
+
+            if (!symbol && ts.isPropertyAccessExpression(node.expression)) {
+                // For property access expressions where we couldn't get a symbol,
+                // try to get the symbol from the signature's declaration
+                const declaration = signature?.getDeclaration();
+                if (declaration) {
+                    symbol = this.checker.getSymbolAtLocation(declaration);
+                }
+
+                // If still no symbol but we have a signature, we can proceed with limited info
+                if (!symbol && signature) {
+                    // For cases like util.isArray where the module is 'any' type
+                    // We'll construct a basic method type from the signature
+                    methodName = node.expression.name.getText();
+
+                    // When there's no symbol but we have a signature, we need to work harder
+                    // to find the declaring type. This happens with CommonJS require() calls
+                    // where the module is typed as 'any' but methods still have signatures
+
+                    // Try to trace back through the AST to find the require() call
+                    let inferredDeclaringType: Type.FullyQualified | undefined;
+                    const objExpr = node.expression.expression;
+
+                    if (ts.isIdentifier(objExpr)) {
+                        // Look for the variable declaration that assigns the require() result
+                        const objSymbol = this.checker.getSymbolAtLocation(objExpr);
+
+                        if (objSymbol && objSymbol.valueDeclaration) {
+                            const valueDecl = objSymbol.valueDeclaration;
+                            if (ts.isVariableDeclaration(valueDecl) && valueDecl.initializer) {
+                                // Check if it's a require() call
+                                if (ts.isCallExpression(valueDecl.initializer)) {
+                                    const callExpr = valueDecl.initializer;
+                                    if (ts.isIdentifier(callExpr.expression) &&
+                                        callExpr.expression.getText() === 'require' &&
+                                        callExpr.arguments.length > 0) {
+                                        // Extract the module name from require('module-name')
+                                        const moduleArg = callExpr.arguments[0];
+                                        if (ts.isStringLiteral(moduleArg)) {
+                                            const moduleName = moduleArg.text;
+
+                                            inferredDeclaringType = {
+                                                kind: Type.Kind.Class,
+                                                fullyQualifiedName: moduleName
+                                            } as Type.FullyQualified;
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+
+                    // Use the inferred type or fall back to unknown
+                    declaringType = inferredDeclaringType || Type.unknownType as Type.FullyQualified;
+
+                    // Create the method type using the helper
+                    return this.createMethodType(signature, node, declaringType, methodName);
+                }
+            }
+
             if (!symbol) {
                 return undefined;
             }
@@ -201,12 +295,12 @@ export class JavaScriptTypeMapping {
                         if ((mappedType as any).keyword === 'String') {
                             declaringType = {
                                 kind: Type.Kind.Class,
-                                fullyQualifiedName: 'lib.String'
+                                fullyQualifiedName: 'String'
                             } as Type.FullyQualified;
                         } else if ((mappedType as any).keyword === 'Number') {
                             declaringType = {
                                 kind: Type.Kind.Class,
-                                fullyQualifiedName: 'lib.Number'
+                                fullyQualifiedName: 'Number'
                             } as Type.FullyQualified;
                         } else {
                             // Fallback for other types
@@ -220,17 +314,17 @@ export class JavaScriptTypeMapping {
 
                 // For string methods like 'hello'.split(), ensure we have a proper declaring type for primitives
                 if (!isImport && declaringType === Type.unknownType) {
-                    // If the expression type is a primitive string, use lib.String as declaring type
+                    // If the expression type is a primitive string, use String as declaring type
                     const typeString = this.checker.typeToString(exprType);
                     if (typeString === 'string' || exprType.flags & ts.TypeFlags.String || exprType.flags & ts.TypeFlags.StringLiteral) {
                         declaringType = {
                             kind: Type.Kind.Class,
-                            fullyQualifiedName: 'lib.String'
+                            fullyQualifiedName: 'string'
                         } as Type.FullyQualified;
                     } else if (typeString === 'number' || exprType.flags & ts.TypeFlags.Number || exprType.flags & ts.TypeFlags.NumberLiteral) {
                         declaringType = {
                             kind: Type.Kind.Class,
-                            fullyQualifiedName: 'lib.Number'
+                            fullyQualifiedName: 'number'
                         } as Type.FullyQualified;
                     } else {
                         // Fallback for other primitive types or unknown
@@ -383,34 +477,8 @@ export class JavaScriptTypeMapping {
             return undefined;
         }
 
-        // Common logic for all method types
-        const returnType = signature.getReturnType();
-        const parameters = signature.getParameters();
-        const parameterTypes: Type[] = [];
-        const parameterNames: string[] = [];
-
-        for (const param of parameters) {
-            parameterNames.push(param.getName());
-            const paramType = this.checker.getTypeOfSymbolAtLocation(param, node);
-            parameterTypes.push(this.getType(paramType));
-        }
-
-        // Create the Type.Method object
-        return Object.assign(new NonDraftableType(), {
-            kind: Type.Kind.Method,
-            declaringType: declaringType,
-            name: methodName,
-            returnType: this.getType(returnType),
-            parameterNames: parameterNames,
-            parameterTypes: parameterTypes,
-            thrownExceptions: [], // JavaScript doesn't have checked exceptions
-            annotations: [],
-            defaultValue: undefined,
-            declaredFormalTypeNames: declaredFormalTypeNames,
-            toJSON: function () {
-                return Type.signature(this);
-            }
-        }) as Type.Method;
+        // Create the method type using the helper
+        return this.createMethodType(signature, node, declaringType, methodName, declaredFormalTypeNames);
     }
 
 
@@ -507,14 +575,9 @@ export class JavaScriptTypeMapping {
             }
         }
 
-        // If it's just a simple name without dots, check if it's a built-in type
-        if (!cleanedName.includes('.')) {
-            if (builtInTypes.has(cleanedName)) {
-                return `lib.${cleanedName}`;
-            }
-        }
-
-        return cleanedName;
+        return cleanedName.endsWith('Constructor') ?
+            cleanedName.substring(0, cleanedName.length - 'Constructor'.length) :
+            cleanedName;
     }