@openrewrite/rewrite 8.67.0-20251111-082857 → 8.67.0-20251111-123004

package/src/javascript/comparator.ts

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 import {JavaScriptVisitor} from './visitor';
-import {J, Type} from '../java';
+import {J, Type, Expression, Statement, isIdentifier} from '../java';
 import {JS, JSX} from './tree';
 import {Cursor, Tree} from "../tree";
 
@@ -73,7 +73,6 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
         return t;
     }
 
-
     /**
      * Generic method to visit a property value using the appropriate visitor method.
      * This ensures wrappers (RightPadded, LeftPadded, Container) are properly tracked on the cursor.
@@ -1838,6 +1837,273 @@ export class JavaScriptSemanticComparatorVisitor extends JavaScriptComparatorVis
         this.lenientTypeMatching = lenientTypeMatching;
     }
 
+    /**
+     * Unwraps parentheses from a tree node recursively.
+     * This allows comparing expressions with and without redundant parentheses.
+     *
+     * @param tree The tree to unwrap
+     * @returns The unwrapped tree
+     */
+    protected unwrap(tree: Tree | undefined): Tree | undefined {
+        if (!tree) {
+            return tree;
+        }
+
+        // Unwrap J.Parentheses nodes recursively
+        if ((tree as any).kind === J.Kind.Parentheses) {
+            const parens = tree as J.Parentheses<any>;
+            return this.unwrap(parens.tree.element as Tree);
+        }
+
+        // Unwrap J.ControlParentheses nodes recursively
+        if ((tree as any).kind === J.Kind.ControlParentheses) {
+            const controlParens = tree as J.ControlParentheses<any>;
+            return this.unwrap(controlParens.tree.element as Tree);
+        }
+
+        return tree;
+    }
+
+    override async visit<R extends J>(j: Tree, p: J, parent?: Cursor): Promise<R | undefined> {
+        // If we've already found a mismatch, abort further processing
+        if (!this.match) {
+            return j as R;
+        }
+
+        // Unwrap parentheses from both trees before comparing
+        const unwrappedJ = this.unwrap(j) || j;
+        const unwrappedP = this.unwrap(p) || p;
+
+        // Skip the kind check that the base class does - semantic matching allows different kinds
+        // (e.g., undefined identifier matching void expression)
+        // Update targetCursor to track the target node in parallel with the pattern cursor
+        const savedTargetCursor = this.targetCursor;
+        this.targetCursor = new Cursor(unwrappedP, this.targetCursor);
+        try {
+            // Call the grandparent's visit to do actual visitation without the kind check
+            return await JavaScriptVisitor.prototype.visit.call(this, unwrappedJ, unwrappedP) as R | undefined;
+        } finally {
+            this.targetCursor = savedTargetCursor;
+        }
+    }
+
+    /**
+     * Override visitArrowFunction to allow semantic equivalence between expression body
+     * and block with single return statement forms.
+     *
+     * Examples:
+     * - `x => x + 1` matches `x => { return x + 1; }`
+     * - `(x, y) => x + y` matches `(x, y) => { return x + y; }`
+     */
+    override async visitArrowFunction(arrowFunction: JS.ArrowFunction, other: J): Promise<J | undefined> {
+        if (!this.match) {
+            return arrowFunction;
+        }
+
+        if (other.kind !== JS.Kind.ArrowFunction) {
+            return this.abort(arrowFunction);
+        }
+
+        const otherArrow = other as JS.ArrowFunction;
+
+        // Compare all properties reflectively except lambda (handled specially below)
+        for (const key of Object.keys(arrowFunction)) {
+            if (key.startsWith('_') || key === 'id' || key === 'markers' || key === 'lambda') {
+                continue;
+            }
+
+            const jValue = (arrowFunction as any)[key];
+            const otherValue = (otherArrow as any)[key];
+
+            // Handle arrays
+            if (Array.isArray(jValue)) {
+                if (!Array.isArray(otherValue) || jValue.length !== otherValue.length) {
+                    return this.abort(arrowFunction);
+                }
+                for (let i = 0; i < jValue.length; i++) {
+                    await this.visitProperty(jValue[i], otherValue[i]);
+                    if (!this.match) return arrowFunction;
+                }
+            } else {
+                await this.visitProperty(jValue, otherValue);
+                if (!this.match) return arrowFunction;
+            }
+        }
+
+        // Compare lambda parameters
+        const params1 = arrowFunction.lambda.parameters.parameters;
+        const params2 = otherArrow.lambda.parameters.parameters;
+        if (params1.length !== params2.length) {
+            return this.abort(arrowFunction);
+        }
+        for (let i = 0; i < params1.length; i++) {
+            await this.visitProperty(params1[i], params2[i]);
+            if (!this.match) return arrowFunction;
+        }
+
+        // Handle semantic equivalence for lambda bodies
+        const body1 = arrowFunction.lambda.body;
+        const body2 = otherArrow.lambda.body;
+
+        // Try to extract the expression from each body
+        const expr1 = this.extractExpression(body1);
+        const expr2 = this.extractExpression(body2);
+
+        if (expr1 && expr2) {
+            // Both have extractable expressions - compare them
+            await this.visit(expr1, expr2);
+        } else {
+            // At least one is not a simple expression or block-with-return
+            // Fall back to exact comparison
+            await this.visit(body1, body2);
+        }
+
+        return arrowFunction;
+    }
+
+    /**
+     * Override visitLambdaParameters to allow semantic equivalence between
+     * arrow functions with and without parentheses around single parameters.
+     *
+     * Examples:
+     * - `x => x + 1` matches `(x) => x + 1`
+     */
+    override async visitLambdaParameters(parameters: J.Lambda.Parameters, other: J): Promise<J | undefined> {
+        if (!this.match) {
+            return parameters;
+        }
+
+        if (other.kind !== J.Kind.LambdaParameters) {
+            return this.abort(parameters);
+        }
+
+        const otherParams = other as J.Lambda.Parameters;
+
+        // Compare all properties except 'parenthesized' using reflection
+        for (const key of Object.keys(parameters)) {
+            if (key.startsWith('_') || key === 'id' || key === 'markers' || key === 'parenthesized') {
+                continue;
+            }
+
+            const jValue = (parameters as any)[key];
+            const otherValue = (otherParams as any)[key];
+
+            // Handle arrays
+            if (Array.isArray(jValue)) {
+                if (!Array.isArray(otherValue) || jValue.length !== otherValue.length) {
+                    return this.abort(parameters);
+                }
+                for (let i = 0; i < jValue.length; i++) {
+                    await this.visitProperty(jValue[i], otherValue[i]);
+                    if (!this.match) return parameters;
+                }
+            } else {
+                await this.visitProperty(jValue, otherValue);
+                if (!this.match) return parameters;
+            }
+        }
+
+        return parameters;
+    }
+
+    /**
+     * Override visitPropertyAssignment to allow semantic equivalence between
+     * object property shorthand and longhand forms.
+     *
+     * Examples:
+     * - `{ x }` matches `{ x: x }`
+     * - `{ x: x, y: y }` matches `{ x, y }`
+     */
+    override async visitPropertyAssignment(propertyAssignment: JS.PropertyAssignment, other: J): Promise<J | undefined> {
+        if (!this.match) {
+            return propertyAssignment;
+        }
+
+        if (other.kind !== JS.Kind.PropertyAssignment) {
+            return this.abort(propertyAssignment);
+        }
+
+        const otherProp = other as JS.PropertyAssignment;
+
+        // Extract property names for semantic comparison
+        const propName = this.getPropertyName(propertyAssignment);
+        const otherPropName = this.getPropertyName(otherProp);
+
+        // Names must match
+        if (!propName || !otherPropName || propName !== otherPropName) {
+            // Can't do semantic comparison without identifiers, fall back to exact comparison
+            return await super.visitPropertyAssignment(propertyAssignment, other);
+        }
+
+        // Detect shorthand (no initializer) vs longhand (has initializer)
+        const isShorthand1 = !propertyAssignment.initializer;
+        const isShorthand2 = !otherProp.initializer;
+
+        if (isShorthand1 === isShorthand2) {
+            // Both shorthand or both longhand - use base comparison
+            return await super.visitPropertyAssignment(propertyAssignment, other);
+        }
+
+        // One is shorthand, one is longhand - check semantic equivalence
+        const longhandProp = isShorthand1 ? otherProp : propertyAssignment;
+
+        // Check if the longhand's initializer is an identifier with the same name as the property
+        if (this.isIdentifierWithName(longhandProp.initializer, propName)) {
+            // Semantically equivalent!
+            return propertyAssignment;
+        } else {
+            // Not equivalent (e.g., { x: y })
+            return this.abort(propertyAssignment);
+        }
+    }
+
+    /**
+     * Extracts the property name from a PropertyAssignment.
+     * Returns the simple name if the property is an identifier, undefined otherwise.
+     */
+    private getPropertyName(prop: JS.PropertyAssignment): string | undefined {
+        const nameExpr = prop.name.element;
+        return isIdentifier(nameExpr) ? nameExpr.simpleName : undefined;
+    }
+
+    /**
+     * Checks if an expression is an identifier with the given name.
+     */
+    private isIdentifierWithName(expr: Expression | undefined, name: string): boolean | undefined {
+        return expr && isIdentifier(expr) && expr.simpleName === name;
+    }
+
+    /**
+     * Extracts the expression from an arrow function body.
+     * Returns the expression if:
+     * - body is already an Expression, OR
+     * - body is a Block with exactly one Return statement
+     * Otherwise returns undefined.
+     */
+    private extractExpression(body: Statement | Expression): Expression | undefined {
+        // If it's already an expression, return it
+        if ((body as any).kind !== J.Kind.Block) {
+            return body as Expression;
+        }
+
+        // It's a block - check if it contains exactly one return statement
+        const block = body as J.Block;
+        if (block.statements.length !== 1) {
+            return undefined;
+        }
+
+        // Unwrap the RightPadded wrapper from the statement
+        const stmtWrapper = block.statements[0];
+        const stmt = stmtWrapper.element;
+
+        if ((stmt as any).kind !== J.Kind.Return) {
+            return undefined;
+        }
+
+        const returnStmt = stmt as J.Return;
+        return returnStmt.expression;
+    }
+
     /**
      * Override visitProperty to allow lenient type matching.
      * When lenientTypeMatching is enabled, null vs Type comparisons are allowed
@@ -2084,9 +2350,17 @@ export class JavaScriptSemanticComparatorVisitor extends JavaScriptComparatorVis
     }
 
     /**
-     * Override identifier comparison to include type checking for field access.
+     * Override identifier comparison to include:
+     * 1. Type checking for field access
+     * 2. Semantic equivalence between `undefined` identifier and void expressions
      */
     override async visitIdentifier(identifier: J.Identifier, other: J): Promise<J | undefined> {
+        // Check if this identifier is "undefined" and the other is a void expression
+        if (identifier.simpleName === 'undefined' && (other as any).kind === JS.Kind.Void) {
+            // Both evaluate to undefined, so they match
+            return identifier;
+        }
+
         if (other.kind !== J.Kind.Identifier) {
             return this.abort(identifier);
         }
@@ -2267,4 +2541,63 @@ export class JavaScriptSemanticComparatorVisitor extends JavaScriptComparatorVis
 
         return methodDeclaration;
     }
+
+    /**
+     * Override visitVoid to allow semantic equivalence with undefined identifier.
+     * This handles the reverse case where the pattern is a void expression
+     * and the source is the undefined identifier.
+     *
+     * Examples:
+     * - `void 0` matches `undefined`
+     * - `void(0)` matches `undefined`
+     * - `void 1` matches `undefined`
+     */
+    override async visitVoid(voidExpr: JS.Void, other: J): Promise<J | undefined> {
+        if (!this.match) {
+            return voidExpr;
+        }
+
+        // Check if the other is an undefined identifier
+        if ((other as any).kind === J.Kind.Identifier) {
+            const identifier = other as J.Identifier;
+            if (identifier.simpleName === 'undefined') {
+                // Both evaluate to undefined, so they match
+                return voidExpr;
+            }
+        }
+
+        // Otherwise delegate to parent
+        return super.visitVoid(voidExpr, other as any);
+    }
+
+    /**
+     * Override visitLiteral to allow semantic equivalence between
+     * different numeric literal formats.
+     *
+     * Examples:
+     * - `255` matches `0xFF`
+     * - `255` matches `0o377`
+     * - `255` matches `0b11111111`
+     * - `1000` matches `1e3`
+     */
+    override async visitLiteral(literal: J.Literal, other: J): Promise<J | undefined> {
+        if (!this.match) {
+            return literal;
+        }
+
+        if ((other as any).kind !== J.Kind.Literal) {
+            return await super.visitLiteral(literal, other);
+        }
+
+        const otherLiteral = other as J.Literal;
+
+        // Only compare value and type, ignoring valueSource (text representation) and unicodeEscapes
+        await this.visitProperty(literal.value, otherLiteral.value);
+        if (!this.match) return literal;
+
+        await this.visitProperty(literal.type, otherLiteral.type);
+        if (!this.match) return literal;
+
+        return literal;
+    }
 }

package/src/javascript/templating/engine.ts

@@ -293,7 +293,10 @@ export class TemplateEngine {
                     const typeString = typeof captureType === 'string'
                         ? captureType
                         : this.typeToString(captureType);
-                    preamble.push(`let ${placeholder}: ${typeString};`);
+                    // Only add preamble if we have a concrete type (not 'any')
+                    if (typeString !== 'any') {
+                        preamble.push(`let ${placeholder}: ${typeString};`);
+                    }
                 }
             } else if (isCaptureValue) {
                 // For CaptureValue, check if the root capture has a type
@@ -304,7 +307,10 @@ export class TemplateEngine {
                         const typeString = typeof captureType === 'string'
                             ? captureType
                             : this.typeToString(captureType);
-                        preamble.push(`let ${placeholder}: ${typeString};`);
+                        // Only add preamble if we have a concrete type (not 'any')
+                        if (typeString !== 'any') {
+                            preamble.push(`let ${placeholder}: ${typeString};`);
+                        }
                     }
                 }
             } else if (isTree(param) && !isTreeArray) {
@@ -312,7 +318,10 @@ export class TemplateEngine {
                 const jElement = param as J;
                 if ((jElement as any).type) {
                     const typeString = this.typeToString((jElement as any).type);
-                    preamble.push(`let ${placeholder}: ${typeString};`);
+                    // Only add preamble if we have a concrete type (not 'any')
+                    if (typeString !== 'any') {
+                        preamble.push(`let ${placeholder}: ${typeString};`);
+                    }
                 }
             }
         }
@@ -435,12 +444,13 @@ export class TemplateEngine {
                 const typeString = typeof captureType === 'string'
                     ? captureType
                     : this.typeToString(captureType);
-                const placeholder = PlaceholderUtils.createCapture(captureName, undefined);
-                preamble.push(`let ${placeholder}: ${typeString};`);
-            } else {
-                const placeholder = PlaceholderUtils.createCapture(captureName, undefined);
-                preamble.push(`let ${placeholder};`);
+                // Only add preamble if we have a concrete type (not 'any')
+                if (typeString !== 'any') {
+                    const placeholder = PlaceholderUtils.createCapture(captureName, undefined);
+                    preamble.push(`let ${placeholder}: ${typeString};`);
+                }
             }
+            // Don't add preamble declarations without types - they don't provide type attribution
         }
 
         // Build the template string with placeholders for captures and raw code