@openrewrite/rewrite 8.66.1 → 8.66.3

package/dist/javascript/comparator.js

@@ -27,7 +27,8 @@ exports.JavaScriptSemanticComparatorVisitor = exports.JavaScriptComparatorVisito
  */
 const visitor_1 = require("./visitor");
 const java_1 = require("../java");
-const tree_1 = require("../tree");
+const tree_1 = require("./tree");
+const tree_2 = require("../tree");
 /**
  * A visitor that compares two AST trees in lock step.
  * It takes another `J` instance as context and visits both trees simultaneously.
@@ -44,13 +45,19 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
     /**
      * Compares two AST trees.
      *
-     * @param tree1 The first tree to compare
-     * @param tree2 The second tree to compare
+     * @param tree1 The first tree to compare (pattern tree)
+     * @param tree2 The second tree to compare (target tree)
+     * @param parentCursor1 Optional parent cursor for the pattern tree (for navigating to root)
+     * @param parentCursor2 Optional parent cursor for the target tree (for navigating to root)
      * @returns true if the trees match, false otherwise
      */
-    compare(tree1, tree2) {
+    compare(tree1, tree2, parentCursor1, parentCursor2) {
         return __awaiter(this, void 0, void 0, function* () {
             this.match = true;
+            // Initialize targetCursor with parent if provided, otherwise undefined (will be set by visit())
+            this.targetCursor = parentCursor2;
+            // Initialize this.cursor (pattern cursor) with parent if provided
+            this.cursor = parentCursor1 || new tree_2.Cursor(undefined, undefined);
             yield this.visit(tree1, tree2);
             return this.match;
         });
@@ -67,37 +74,161 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
     }
     /**
      * Aborts the visit operation by setting the match flag to false.
+     *
+     * @param t The node being compared
+     * @param reason Optional reason for the mismatch (e.g., 'kind-mismatch', 'property-mismatch')
+     * @param propertyName Optional property name where mismatch occurred
+     * @param expected Optional expected value
+     * @param actual Optional actual value
      */
-    abort(t) {
+    abort(t, reason, propertyName, expected, actual) {
         this.match = false;
         return t;
     }
+    /**
+     * Specialized abort methods for common mismatch scenarios.
+     * These provide a cleaner API at call sites.
+     * Can be overridden in subclasses to extract values from cursors and provide richer error messages.
+     */
+    kindMismatch() {
+        var _a;
+        const pattern = (_a = this.cursor) === null || _a === void 0 ? void 0 : _a.value;
+        return this.abort(pattern, 'kind-mismatch');
+    }
+    structuralMismatch(propertyName) {
+        var _a;
+        const pattern = (_a = this.cursor) === null || _a === void 0 ? void 0 : _a.value;
+        return this.abort(pattern, 'structural-mismatch', propertyName);
+    }
+    arrayLengthMismatch(propertyName) {
+        var _a;
+        const pattern = (_a = this.cursor) === null || _a === void 0 ? void 0 : _a.value;
+        return this.abort(pattern, 'array-length-mismatch', propertyName);
+    }
+    valueMismatch(propertyName, expected, actual) {
+        var _a, _b, _c, _d;
+        const pattern = (_a = this.cursor) === null || _a === void 0 ? void 0 : _a.value;
+        // If values not provided, try to extract from cursors (only if propertyName is available)
+        const expectedVal = expected !== undefined ? expected : (propertyName ? pattern === null || pattern === void 0 ? void 0 : pattern[propertyName] : pattern);
+        const actualVal = actual !== undefined ? actual : (propertyName ? (_c = (_b = this.targetCursor) === null || _b === void 0 ? void 0 : _b.value) === null || _c === void 0 ? void 0 : _c[propertyName] : (_d = this.targetCursor) === null || _d === void 0 ? void 0 : _d.value);
+        return this.abort(pattern, 'value-mismatch', propertyName, expectedVal, actualVal);
+    }
+    typeMismatch(propertyName) {
+        var _a, _b;
+        const pattern = (_a = this.cursor) === null || _a === void 0 ? void 0 : _a.value;
+        const target = (_b = this.targetCursor) === null || _b === void 0 ? void 0 : _b.value;
+        return this.abort(pattern, 'type-mismatch', propertyName, pattern === null || pattern === void 0 ? void 0 : pattern.type, target === null || target === void 0 ? void 0 : target.type);
+    }
+    /**
+     * Helper method to visit an array property by iterating through both arrays in lock-step.
+     * Checks length mismatch first, then visits each element pair.
+     * Can be overridden in subclasses to add path tracking or other instrumentation.
+     *
+     * @param parent The parent node containing the array property
+     * @param propertyName The name of the array property
+     * @param array1 The array from the first tree
+     * @param array2 The array from the second tree
+     * @param visitor Function to visit each element pair (no need to return anything)
+     * @returns undefined, modifying this.match if a mismatch occurs
+     */
+    visitArrayProperty(parent, propertyName, array1, array2, visitor) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Check length mismatch
+            if (array1.length !== array2.length) {
+                this.arrayLengthMismatch(propertyName);
+                return;
+            }
+            // Visit each element in lock step
+            for (let i = 0; i < array1.length; i++) {
+                yield visitor(array1[i], array2[i], i);
+                if (!this.match)
+                    return;
+            }
+        });
+    }
+    /**
+     * Helper method to visit a container property with proper context.
+     * Can be overridden in subclasses to add path tracking or other instrumentation.
+     *
+     * @param parent The parent node containing the container property
+     * @param propertyName The name of the container property
+     * @param container The container from the first tree
+     * @param otherContainer The container from the second tree
+     * @returns The container from the first tree
+     */
+    visitContainerProperty(propertyName, container, otherContainer) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Default implementation just calls visitContainer
+            // Subclasses can override to add property context
+            yield this.visitContainer(container, otherContainer);
+            return container;
+        });
+    }
+    /**
+     * Helper to visit a RightPadded property with property context.
+     * This allows subclasses to track which property is being visited.
+     *
+     * @param propertyName The property name for context
+     * @param rightPadded The RightPadded from the first tree
+     * @param otherRightPadded The RightPadded from the second tree
+     * @returns The RightPadded from the first tree
+     */
+    visitRightPaddedProperty(propertyName, rightPadded, otherRightPadded) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Default implementation just calls visitRightPadded
+            // Subclasses can override to add property context
+            return yield this.visitRightPadded(rightPadded, otherRightPadded);
+        });
+    }
+    /**
+     * Helper to visit a LeftPadded property with property context.
+     * This allows subclasses to track which property is being visited.
+     *
+     * @param propertyName The property name for context
+     * @param leftPadded The LeftPadded from the first tree
+     * @param otherLeftPadded The LeftPadded from the second tree
+     * @returns The LeftPadded from the first tree
+     */
+    visitLeftPaddedProperty(propertyName, leftPadded, otherLeftPadded) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Default implementation just calls visitLeftPadded
+            // Subclasses can override to add property context
+            return yield this.visitLeftPadded(leftPadded, otherLeftPadded);
+        });
+    }
     /**
      * Generic method to visit a property value using the appropriate visitor method.
      * This ensures wrappers (RightPadded, LeftPadded, Container) are properly tracked on the cursor.
      *
      * @param j The property value from the first tree
      * @param other The corresponding property value from the second tree
+     * @param propertyName Optional property name for error reporting
      * @returns The visited property value from the first tree
      */
-    visitProperty(j, other) {
+    visitProperty(j, other, propertyName) {
         return __awaiter(this, void 0, void 0, function* () {
             // Handle null/undefined (but not other falsy values like 0, false, '')
             if (j == null || other == null) {
                 if (j !== other) {
-                    this.abort(j);
+                    return this.structuralMismatch(propertyName);
                 }
                 return j;
             }
             const kind = j.kind;
             // Check wrappers by kind
             if (kind === java_1.J.Kind.RightPadded) {
-                return yield this.visitRightPadded(j, other);
+                return propertyName ? yield this.visitRightPaddedProperty(propertyName, j, other) :
+                    yield this.visitRightPadded(j, other);
             }
             if (kind === java_1.J.Kind.LeftPadded) {
-                return yield this.visitLeftPadded(j, other);
+                return propertyName ? yield this.visitLeftPaddedProperty(propertyName, j, other) :
+                    yield this.visitLeftPadded(j, other);
             }
             if (kind === java_1.J.Kind.Container) {
+                // Use visitContainerProperty when propertyName is provided for proper context tracking
+                if (propertyName) {
+                    return yield this.visitContainerProperty(propertyName, j, other);
+                }
                 return yield this.visitContainer(j, other);
             }
             // Check if it's a Space (skip comparison)
@@ -114,7 +245,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
             }
             // For primitive values, compare directly
             if (j !== other) {
-                this.abort(j);
+                return this.valueMismatch(propertyName, j, other);
             }
             return j;
         });
@@ -130,17 +261,16 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitElement(j, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match) {
+            if (!this.match)
                 return j;
-            }
             // Check if kinds match
             if (j.kind !== other.kind) {
-                return this.abort(j);
+                return this.kindMismatch();
             }
             // Iterate over all properties
             for (const key of Object.keys(j)) {
                 // Skip internal/private properties, id property, and markers property
-                if (key.startsWith('_') || key === 'id' || key === 'markers') {
+                if (key.startsWith('_') || key === 'kind' || key === 'id' || key === 'markers') {
                     continue;
                 }
                 const jValue = j[key];
@@ -148,21 +278,19 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
                 // Handle arrays - compare element by element
                 if (Array.isArray(jValue)) {
                     if (!Array.isArray(otherValue) || jValue.length !== otherValue.length) {
-                        return this.abort(j);
+                        return this.arrayLengthMismatch(key);
                     }
                     for (let i = 0; i < jValue.length; i++) {
-                        yield this.visitProperty(jValue[i], otherValue[i]);
-                        if (!this.match) {
+                        yield this.visitProperty(jValue[i], otherValue[i], `${key}[${i}]`);
+                        if (!this.match)
                             return j;
-                        }
                     }
                 }
                 else {
                     // Visit the property (which will handle wrappers, trees, primitives, etc.)
-                    yield this.visitProperty(jValue, otherValue);
-                    if (!this.match) {
+                    yield this.visitProperty(jValue, otherValue, key);
+                    if (!this.match)
                         return j;
-                    }
                 }
             }
             return j;
@@ -174,39 +302,52 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
         });
         return __awaiter(this, void 0, void 0, function* () {
             // If we've already found a mismatch, abort further processing
-            if (!this.match) {
+            if (!this.match)
                 return j;
-            }
             // Check if the nodes have the same kind
             if (!this.hasSameKind(j, p)) {
-                return this.abort(j);
+                return this.kindMismatch();
+            }
+            // Update targetCursor to track the target node in parallel with the pattern cursor
+            // (Can be overridden by subclasses if they need cursor access before calling super)
+            const savedTargetCursor = this.targetCursor;
+            this.targetCursor = new tree_2.Cursor(p, this.targetCursor);
+            try {
+                // Continue with normal visitation, passing the other node as context
+                return yield _super.visit.call(this, j, p);
+            }
+            finally {
+                this.targetCursor = savedTargetCursor;
             }
-            // Continue with normal visitation, passing the other node as context
-            return _super.visit.call(this, j, p);
         });
     }
     /**
      * Override visitRightPadded to compare only the elements, not markers or spacing.
      * The context parameter p contains the corresponding element from the other tree.
      * Pushes the wrapper onto the cursor stack so captures can access it.
+     * Also updates targetCursor in parallel.
      */
     visitRightPadded(right, p) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match) {
+            if (!this.match)
                 return right;
-            }
             // Extract the other element if it's also a RightPadded
-            const otherElement = p.kind === java_1.J.Kind.RightPadded
-                ? p.element
-                : p;
-            // Push wrapper onto cursor, then compare only the elements, not markers or spacing
+            const isRightPadded = p.kind === java_1.J.Kind.RightPadded;
+            const otherWrapper = isRightPadded ? p : undefined;
+            const otherElement = isRightPadded ? otherWrapper.element : p;
+            // Push wrappers onto both cursors, then compare only the elements, not markers or spacing
             const savedCursor = this.cursor;
-            this.cursor = new tree_1.Cursor(right, this.cursor);
+            const savedTargetCursor = this.targetCursor;
+            this.cursor = new tree_2.Cursor(right, this.cursor);
+            this.targetCursor = otherWrapper ? new tree_2.Cursor(otherWrapper, this.targetCursor) : this.targetCursor;
             try {
+                // Call visitProperty without propertyName to avoid pushing spurious 'element' path entries
+                // The property context should be provided through visitRightPaddedProperty() if needed
                 yield this.visitProperty(right.element, otherElement);
             }
             finally {
                 this.cursor = savedCursor;
+                this.targetCursor = savedTargetCursor;
             }
             return right;
         });
@@ -215,24 +356,29 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * Override visitLeftPadded to compare only the elements, not markers or spacing.
      * The context parameter p contains the corresponding element from the other tree.
      * Pushes the wrapper onto the cursor stack so captures can access it.
+     * Also updates targetCursor in parallel.
      */
     visitLeftPadded(left, p) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match) {
+            if (!this.match)
                 return left;
-            }
             // Extract the other element if it's also a LeftPadded
-            const otherElement = p.kind === java_1.J.Kind.LeftPadded
-                ? p.element
-                : p;
-            // Push wrapper onto cursor, then compare only the elements, not markers or spacing
+            const isLeftPadded = p.kind === java_1.J.Kind.LeftPadded;
+            const otherWrapper = isLeftPadded ? p : undefined;
+            const otherElement = isLeftPadded ? otherWrapper.element : p;
+            // Push wrappers onto both cursors, then compare only the elements, not markers or spacing
             const savedCursor = this.cursor;
-            this.cursor = new tree_1.Cursor(left, this.cursor);
+            const savedTargetCursor = this.targetCursor;
+            this.cursor = new tree_2.Cursor(left, this.cursor);
+            this.targetCursor = otherWrapper ? new tree_2.Cursor(otherWrapper, this.targetCursor) : this.targetCursor;
             try {
+                // Call visitProperty without propertyName to avoid pushing spurious 'element' path entries
+                // The property context should be provided through visitLeftPaddedProperty() if needed
                 yield this.visitProperty(left.element, otherElement);
             }
             finally {
                 this.cursor = savedCursor;
+                this.targetCursor = savedTargetCursor;
             }
             return left;
         });
@@ -241,33 +387,35 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * Override visitContainer to compare only the elements, not markers or spacing.
      * The context parameter p contains the corresponding element from the other tree.
      * Pushes the wrapper onto the cursor stack so captures can access it.
+     * Also updates targetCursor in parallel.
      */
     visitContainer(container, p) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match) {
+            if (!this.match)
                 return container;
-            }
             // Extract the other elements if it's also a Container
-            const otherElements = p.kind === java_1.J.Kind.Container
-                ? p.elements
-                : p;
+            const isContainer = p.kind === java_1.J.Kind.Container;
+            const otherContainer = isContainer ? p : undefined;
+            const otherElements = isContainer ? otherContainer.elements : p;
             // Compare elements array length
             if (container.elements.length !== otherElements.length) {
-                return this.abort(container);
+                return this.arrayLengthMismatch('elements');
             }
-            // Push wrapper onto cursor, then compare each element
+            // Push wrappers onto both cursors, then compare each element
             const savedCursor = this.cursor;
-            this.cursor = new tree_1.Cursor(container, this.cursor);
+            const savedTargetCursor = this.targetCursor;
+            this.cursor = new tree_2.Cursor(container, this.cursor);
+            this.targetCursor = otherContainer ? new tree_2.Cursor(otherContainer, this.targetCursor) : this.targetCursor;
             try {
                 for (let i = 0; i < container.elements.length; i++) {
                     yield this.visitProperty(container.elements[i], otherElements[i]);
-                    if (!this.match) {
-                        return this.abort(container);
-                    }
+                    if (!this.match)
+                        return container;
                 }
             }
             finally {
                 this.cursor = savedCursor;
+                this.targetCursor = savedTargetCursor;
             }
             return container;
         });
@@ -1934,12 +2082,255 @@ class JavaScriptSemanticComparatorVisitor extends JavaScriptComparatorVisitor {
         super();
         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
+     */
+    unwrap(tree) {
+        if (!tree) {
+            return tree;
+        }
+        // Unwrap J.Parentheses nodes recursively
+        if (tree.kind === java_1.J.Kind.Parentheses) {
+            const parens = tree;
+            return this.unwrap(parens.tree.element);
+        }
+        // Unwrap J.ControlParentheses nodes recursively
+        if (tree.kind === java_1.J.Kind.ControlParentheses) {
+            const controlParens = tree;
+            return this.unwrap(controlParens.tree.element);
+        }
+        return tree;
+    }
+    visit(j, p, parent) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // If we've already found a mismatch, abort further processing
+            if (!this.match)
+                return j;
+            // 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 tree_2.Cursor(unwrappedP, this.targetCursor);
+            try {
+                // Call the grandparent's visit to do actual visitation without the kind check
+                return yield visitor_1.JavaScriptVisitor.prototype.visit.call(this, unwrappedJ, unwrappedP);
+            }
+            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; }`
+     */
+    visitArrowFunction(arrowFunction, other) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.match)
+                return arrowFunction;
+            if (other.kind !== tree_1.JS.Kind.ArrowFunction) {
+                return this.kindMismatch();
+            }
+            const otherArrow = other;
+            // 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[key];
+                const otherValue = otherArrow[key];
+                // Handle arrays
+                if (Array.isArray(jValue)) {
+                    if (!Array.isArray(otherValue) || jValue.length !== otherValue.length) {
+                        return this.arrayLengthMismatch(key);
+                    }
+                    for (let i = 0; i < jValue.length; i++) {
+                        yield this.visitProperty(jValue[i], otherValue[i]);
+                        if (!this.match)
+                            return arrowFunction;
+                    }
+                }
+                else {
+                    yield 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.arrayLengthMismatch('lambda.parameters.parameters');
+            }
+            for (let i = 0; i < params1.length; i++) {
+                yield 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
+                yield this.visit(expr1, expr2);
+            }
+            else {
+                // At least one is not a simple expression or block-with-return
+                // Fall back to exact comparison
+                yield 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`
+     */
+    visitLambdaParameters(parameters, other) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.match)
+                return parameters;
+            if (other.kind !== java_1.J.Kind.LambdaParameters) {
+                return this.kindMismatch();
+            }
+            const otherParams = other;
+            // 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[key];
+                const otherValue = otherParams[key];
+                // Handle arrays
+                if (Array.isArray(jValue)) {
+                    if (!Array.isArray(otherValue) || jValue.length !== otherValue.length) {
+                        return this.arrayLengthMismatch(key);
+                    }
+                    for (let i = 0; i < jValue.length; i++) {
+                        yield this.visitProperty(jValue[i], otherValue[i]);
+                        if (!this.match)
+                            return parameters;
+                    }
+                }
+                else {
+                    yield 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 }`
+     */
+    visitPropertyAssignment(propertyAssignment, other) {
+        const _super = Object.create(null, {
+            visitPropertyAssignment: { get: () => super.visitPropertyAssignment }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.match)
+                return propertyAssignment;
+            if (other.kind !== tree_1.JS.Kind.PropertyAssignment) {
+                return this.kindMismatch();
+            }
+            const otherProp = other;
+            // 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 yield _super.visitPropertyAssignment.call(this, 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 yield _super.visitPropertyAssignment.call(this, 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.structuralMismatch('initializer');
+            }
+        });
+    }
+    /**
+     * Extracts the property name from a PropertyAssignment.
+     * Returns the simple name if the property is an identifier, undefined otherwise.
+     */
+    getPropertyName(prop) {
+        const nameExpr = prop.name.element;
+        return (0, java_1.isIdentifier)(nameExpr) ? nameExpr.simpleName : undefined;
+    }
+    /**
+     * Checks if an expression is an identifier with the given name.
+     */
+    isIdentifierWithName(expr, name) {
+        return expr && (0, java_1.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.
+     */
+    extractExpression(body) {
+        // If it's already an expression, return it
+        if (body.kind !== java_1.J.Kind.Block) {
+            return body;
+        }
+        // It's a block - check if it contains exactly one return statement
+        const block = body;
+        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.kind !== java_1.J.Kind.Return) {
+            return undefined;
+        }
+        const returnStmt = stmt;
+        return returnStmt.expression;
+    }
     /**
      * Override visitProperty to allow lenient type matching.
      * When lenientTypeMatching is enabled, null vs Type comparisons are allowed
      * (where one value is null/undefined and the other is a Type object).
      */
-    visitProperty(j, other) {
+    visitProperty(j, other, propertyName) {
         const _super = Object.create(null, {
             visitProperty: { get: () => super.visitProperty }
         });
@@ -1953,7 +2344,7 @@ class JavaScriptSemanticComparatorVisitor extends JavaScriptComparatorVisitor {
                     const isTypeComparison = (jKind && typeof jKind === 'string' && jKind.startsWith('org.openrewrite.java.tree.JavaType$')) ||
                         (otherKind && typeof otherKind === 'string' && otherKind.startsWith('org.openrewrite.java.tree.JavaType$'));
                     if (!isTypeComparison) {
-                        this.abort(j);
+                        this.structuralMismatch(propertyName);
                     }
                 }
                 return j;
@@ -1972,8 +2363,10 @@ class JavaScriptSemanticComparatorVisitor extends JavaScriptComparatorVisitor {
             // Lenient mode: if either type is undefined, allow the match
             return this.lenientTypeMatching ? true : target === source;
         }
-        if (target.kind !== source.kind) {
-            return false;
+        if (target.kind !== source.kind && (target.kind == java_1.Type.Kind.Unknown || source.kind == java_1.Type.Kind.Unknown)) {
+            // In lenient mode, allow kind mismatches (e.g., Unknown vs proper type)
+            // This handles cases where pattern has unresolved types
+            return this.lenientTypeMatching;
         }
         // For method types, check declaring type
         // Note: We don't check the name field because it might not be fully resolved in patterns
@@ -2037,108 +2430,136 @@ class JavaScriptSemanticComparatorVisitor extends JavaScriptComparatorVisitor {
         });
         return __awaiter(this, void 0, void 0, function* () {
             if (other.kind !== java_1.J.Kind.MethodInvocation) {
-                return this.abort(method);
+                return this.kindMismatch();
             }
             const otherMethod = other;
-            // Check basic structural equality first
-            if (method.name.simpleName !== otherMethod.name.simpleName ||
-                method.arguments.elements.length !== otherMethod.arguments.elements.length) {
-                return this.abort(method);
-            }
-            // Check type attribution
-            // Both must have method types for semantic equality
-            if (!method.methodType || !otherMethod.methodType) {
-                // Lenient mode: if either has no type, allow structural matching
-                if (this.lenientTypeMatching) {
+            // Check if we can skip name checking based on type attribution
+            // We can only skip the name check if both have method types AND they represent the SAME method
+            // (not just type-compatible methods, but the actual same function with same FQN)
+            let canSkipNameCheck = false;
+            if (method.methodType && otherMethod.methodType) {
+                // Check if both method types have fully qualified declaring types with the same FQN
+                // This indicates they're the same method from the same module (possibly aliased)
+                const methodDeclaringType = method.methodType.declaringType;
+                const otherDeclaringType = otherMethod.methodType.declaringType;
+                if (methodDeclaringType && otherDeclaringType &&
+                    java_1.Type.isFullyQualified(methodDeclaringType) && java_1.Type.isFullyQualified(otherDeclaringType)) {
+                    const methodFQN = java_1.Type.FullyQualified.getFullyQualifiedName(methodDeclaringType);
+                    const otherFQN = java_1.Type.FullyQualified.getFullyQualifiedName(otherDeclaringType);
+                    // Same module/class AND same method name in the type = same method (can be aliased)
+                    if (methodFQN === otherFQN && method.methodType.name === otherMethod.methodType.name) {
+                        canSkipNameCheck = true;
+                    }
+                    // If FQNs or method names don't match, we can't skip name check - fall through to name checking
+                }
+                // If one or both don't have fully qualified types, we can't safely skip name checking
+                // Fall through to normal name comparison below
+            }
+            // Check names unless we determined we can skip based on type FQN matching
+            if (!canSkipNameCheck) {
+                if (method.name.simpleName !== otherMethod.name.simpleName) {
+                    return this.valueMismatch('name.simpleName', method.name.simpleName, otherMethod.name.simpleName);
+                }
+                // In strict mode, check type attribution requirements
+                if (!this.lenientTypeMatching) {
+                    // Strict mode: if one has type but the other doesn't, they don't match
+                    if ((method.methodType && !otherMethod.methodType) ||
+                        (!method.methodType && otherMethod.methodType)) {
+                        return this.typeMismatch('methodType');
+                    }
+                }
+                // If neither has type, use structural comparison
+                if (!method.methodType && !otherMethod.methodType) {
                     return _super.visitMethodInvocation.call(this, method, other);
                 }
-                // Strict mode: if one has type but the other doesn't, they don't match
-                if (method.methodType || otherMethod.methodType) {
-                    return this.abort(method);
+                // If both have types with FQ declaring types, verify they're compatible
+                // (This prevents matching completely different methods like util.isArray vs util.isBoolean)
+                if (method.methodType && otherMethod.methodType) {
+                    const methodDeclaringType = method.methodType.declaringType;
+                    const otherDeclaringType = otherMethod.methodType.declaringType;
+                    if (methodDeclaringType && otherDeclaringType &&
+                        java_1.Type.isFullyQualified(methodDeclaringType) && java_1.Type.isFullyQualified(otherDeclaringType)) {
+                        const methodFQN = java_1.Type.FullyQualified.getFullyQualifiedName(methodDeclaringType);
+                        const otherFQN = java_1.Type.FullyQualified.getFullyQualifiedName(otherDeclaringType);
+                        // Different declaring types = different methods, even with same name
+                        if (methodFQN !== otherFQN) {
+                            return this.valueMismatch('methodType.declaringType');
+                        }
+                    }
                 }
-                // If neither has type, fall through to structural comparison
-                return _super.visitMethodInvocation.call(this, method, other);
-            }
-            // Both have types - check they match semantically
-            const typesMatch = this.isOfType(method.methodType, otherMethod.methodType);
-            if (!typesMatch) {
-                // Types don't match - abort comparison
-                return this.abort(method);
-            }
-            // Types match! Now check if we can ignore receiver differences.
-            // We can only ignore receiver differences when one or both receivers are identifiers
-            // that represent module/namespace imports (e.g., `util` in `util.isDate()`).
-            // For other receivers (e.g., variables, expressions), we must compare them.
-            const canIgnoreReceiverDifference = 
-            // Case 1: One has no select (direct call like `forwardRef()`), other has select (namespace like `React.forwardRef()`)
-            (!method.select && otherMethod.select) ||
-                (method.select && !otherMethod.select);
-            if (!canIgnoreReceiverDifference) {
-                // Both have selects or both don't - must compare them structurally
+            }
+            // When types match (canSkipNameCheck = true), we can skip select comparison entirely.
+            // This allows matching forwardRef() vs React.forwardRef() where types indicate same method.
+            if (!canSkipNameCheck) {
+                // Types didn't provide a match - must compare receivers structurally
                 if ((method.select === undefined) !== (otherMethod.select === undefined)) {
-                    return this.abort(method);
+                    return this.structuralMismatch('select');
                 }
                 if (method.select && otherMethod.select) {
-                    yield this.visit(method.select.element, otherMethod.select.element);
+                    yield this.visitRightPaddedProperty('select', method.select, otherMethod.select);
+                    if (!this.match)
+                        return method;
                 }
             }
+            // else: types matched, skip select comparison (allows namespace vs named imports)
             // Compare type parameters
             if ((method.typeParameters === undefined) !== (otherMethod.typeParameters === undefined)) {
-                return this.abort(method);
+                return this.structuralMismatch('typeParameters');
             }
             if (method.typeParameters && otherMethod.typeParameters) {
-                if (method.typeParameters.elements.length !== otherMethod.typeParameters.elements.length) {
-                    return this.abort(method);
-                }
-                for (let i = 0; i < method.typeParameters.elements.length; i++) {
-                    yield this.visit(method.typeParameters.elements[i].element, otherMethod.typeParameters.elements[i].element);
-                    if (!this.match) {
-                        return this.abort(method);
-                    }
-                }
+                yield this.visitContainerProperty('typeParameters', method.typeParameters, otherMethod.typeParameters);
+                if (!this.match)
+                    return method;
             }
-            // Compare name (already checked simpleName above, but visit for markers/prefix)
-            yield this.visit(method.name, otherMethod.name);
-            if (!this.match) {
-                return this.abort(method);
+            // Compare name
+            // If we determined we can skip name check (same FQN method, possibly aliased), skip it
+            // This allows matching aliased imports where names differ but types are the same
+            if (!canSkipNameCheck) {
+                yield this.visit(method.name, otherMethod.name);
+                if (!this.match)
+                    return method;
             }
             // Compare arguments
-            for (let i = 0; i < method.arguments.elements.length; i++) {
-                yield this.visit(method.arguments.elements[i].element, otherMethod.arguments.elements[i].element);
-                if (!this.match) {
-                    return this.abort(method);
-                }
-            }
+            yield this.visitContainerProperty('arguments', method.arguments, otherMethod.arguments);
+            if (!this.match)
+                return method;
             return method;
         });
     }
     /**
-     * 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
      */
     visitIdentifier(identifier, other) {
         const _super = Object.create(null, {
             visitIdentifier: { get: () => super.visitIdentifier }
         });
         return __awaiter(this, void 0, void 0, function* () {
+            // Check if this identifier is "undefined" and the other is a void expression
+            if (identifier.simpleName === 'undefined' && other.kind === tree_1.JS.Kind.Void) {
+                // Both evaluate to undefined, so they match
+                return identifier;
+            }
             if (other.kind !== java_1.J.Kind.Identifier) {
-                return this.abort(identifier);
+                return this.kindMismatch();
             }
             const otherIdentifier = other;
             // Check name matches
             if (identifier.simpleName !== otherIdentifier.simpleName) {
-                return this.abort(identifier);
+                return this.valueMismatch('simpleName');
             }
             // For identifiers with field types, check type attribution
             if (identifier.fieldType && otherIdentifier.fieldType) {
                 if (!this.isOfType(identifier.fieldType, otherIdentifier.fieldType)) {
-                    return this.abort(identifier);
+                    return this.typeMismatch('fieldType');
                 }
             }
             else if (identifier.fieldType || otherIdentifier.fieldType) {
                 // Lenient mode: if either has no type, allow structural matching
                 if (!this.lenientTypeMatching) {
                     // Strict mode: if only one has a type, they don't match
-                    return this.abort(identifier);
+                    return this.typeMismatch('fieldType');
                 }
             }
             return _super.visitIdentifier.call(this, identifier, other);
@@ -2153,27 +2574,17 @@ class JavaScriptSemanticComparatorVisitor extends JavaScriptComparatorVisitor {
         return __awaiter(this, void 0, void 0, function* () {
             const otherVariableDeclarations = other;
             // Visit leading annotations
-            if (variableDeclarations.leadingAnnotations.length !== otherVariableDeclarations.leadingAnnotations.length) {
-                return this.abort(variableDeclarations);
-            }
-            for (let i = 0; i < variableDeclarations.leadingAnnotations.length; i++) {
-                yield this.visit(variableDeclarations.leadingAnnotations[i], otherVariableDeclarations.leadingAnnotations[i]);
-                if (!this.match)
-                    return variableDeclarations;
-            }
+            yield this.visitArrayProperty(variableDeclarations, 'leadingAnnotations', variableDeclarations.leadingAnnotations, otherVariableDeclarations.leadingAnnotations, (ann1, ann2) => __awaiter(this, void 0, void 0, function* () { yield this.visit(ann1, ann2); }));
+            if (!this.match)
+                return variableDeclarations;
             // Visit modifiers
-            if (variableDeclarations.modifiers.length !== otherVariableDeclarations.modifiers.length) {
-                return this.abort(variableDeclarations);
-            }
-            for (let i = 0; i < variableDeclarations.modifiers.length; i++) {
-                yield this.visit(variableDeclarations.modifiers[i], otherVariableDeclarations.modifiers[i]);
-                if (!this.match)
-                    return variableDeclarations;
-            }
+            yield this.visitArrayProperty(variableDeclarations, 'modifiers', variableDeclarations.modifiers, otherVariableDeclarations.modifiers, (mod1, mod2) => __awaiter(this, void 0, void 0, function* () { yield this.visit(mod1, mod2); }));
+            if (!this.match)
+                return variableDeclarations;
             // Compare typeExpression - lenient matching allows one to be undefined
             if ((variableDeclarations.typeExpression === undefined) !== (otherVariableDeclarations.typeExpression === undefined)) {
                 if (!this.lenientTypeMatching) {
-                    return this.abort(variableDeclarations);
+                    return this.structuralMismatch('typeExpression');
                 }
                 // In lenient mode, skip type comparison and continue
             }
@@ -2185,18 +2596,12 @@ class JavaScriptSemanticComparatorVisitor extends JavaScriptComparatorVisitor {
             }
             // Compare varargs
             if ((variableDeclarations.varargs === undefined) !== (otherVariableDeclarations.varargs === undefined)) {
-                return this.abort(variableDeclarations);
+                return this.structuralMismatch('varargs');
             }
             // Compare variables
-            if (variableDeclarations.variables.length !== otherVariableDeclarations.variables.length) {
-                return this.abort(variableDeclarations);
-            }
-            // Visit each variable in lock step
-            for (let i = 0; i < variableDeclarations.variables.length; i++) {
-                yield this.visit(variableDeclarations.variables[i].element, otherVariableDeclarations.variables[i].element);
-                if (!this.match)
-                    return variableDeclarations;
-            }
+            yield this.visitArrayProperty(variableDeclarations, 'variables', variableDeclarations.variables, otherVariableDeclarations.variables, (var1, var2) => __awaiter(this, void 0, void 0, function* () { yield this.visitRightPadded(var1, var2); }));
+            if (!this.match)
+                return variableDeclarations;
             return variableDeclarations;
         });
     }
@@ -2209,26 +2614,16 @@ class JavaScriptSemanticComparatorVisitor extends JavaScriptComparatorVisitor {
         return __awaiter(this, void 0, void 0, function* () {
             const otherMethodDeclaration = other;
             // Visit leading annotations
-            if (methodDeclaration.leadingAnnotations.length !== otherMethodDeclaration.leadingAnnotations.length) {
-                return this.abort(methodDeclaration);
-            }
-            for (let i = 0; i < methodDeclaration.leadingAnnotations.length; i++) {
-                yield this.visit(methodDeclaration.leadingAnnotations[i], otherMethodDeclaration.leadingAnnotations[i]);
-                if (!this.match)
-                    return methodDeclaration;
-            }
+            yield this.visitArrayProperty(methodDeclaration, 'leadingAnnotations', methodDeclaration.leadingAnnotations, otherMethodDeclaration.leadingAnnotations, (ann1, ann2) => __awaiter(this, void 0, void 0, function* () { yield this.visit(ann1, ann2); }));
+            if (!this.match)
+                return methodDeclaration;
             // Visit modifiers
-            if (methodDeclaration.modifiers.length !== otherMethodDeclaration.modifiers.length) {
-                return this.abort(methodDeclaration);
-            }
-            for (let i = 0; i < methodDeclaration.modifiers.length; i++) {
-                yield this.visit(methodDeclaration.modifiers[i], otherMethodDeclaration.modifiers[i]);
-                if (!this.match)
-                    return methodDeclaration;
-            }
+            yield this.visitArrayProperty(methodDeclaration, 'modifiers', methodDeclaration.modifiers, otherMethodDeclaration.modifiers, (mod1, mod2) => __awaiter(this, void 0, void 0, function* () { yield this.visit(mod1, mod2); }));
+            if (!this.match)
+                return methodDeclaration;
             // Visit type parameters if present
             if (!!methodDeclaration.typeParameters !== !!otherMethodDeclaration.typeParameters) {
-                return this.abort(methodDeclaration);
+                return this.structuralMismatch('typeParameters');
             }
             if (methodDeclaration.typeParameters && otherMethodDeclaration.typeParameters) {
                 yield this.visit(methodDeclaration.typeParameters, otherMethodDeclaration.typeParameters);
@@ -2238,7 +2633,7 @@ class JavaScriptSemanticComparatorVisitor extends JavaScriptComparatorVisitor {
             // Compare returnTypeExpression - lenient matching allows one to be undefined
             if ((methodDeclaration.returnTypeExpression === undefined) !== (otherMethodDeclaration.returnTypeExpression === undefined)) {
                 if (!this.lenientTypeMatching) {
-                    return this.abort(methodDeclaration);
+                    return this.typeMismatch('returnTypeExpression');
                 }
                 // In lenient mode, skip type comparison and continue
             }
@@ -2253,33 +2648,21 @@ class JavaScriptSemanticComparatorVisitor extends JavaScriptComparatorVisitor {
             if (!this.match)
                 return methodDeclaration;
             // Compare parameters
-            if (methodDeclaration.parameters.elements.length !== otherMethodDeclaration.parameters.elements.length) {
-                return this.abort(methodDeclaration);
-            }
-            // Visit each parameter in lock step
-            for (let i = 0; i < methodDeclaration.parameters.elements.length; i++) {
-                yield this.visit(methodDeclaration.parameters.elements[i].element, otherMethodDeclaration.parameters.elements[i].element);
-                if (!this.match)
-                    return methodDeclaration;
-            }
+            yield this.visitContainer(methodDeclaration.parameters, otherMethodDeclaration.parameters);
+            if (!this.match)
+                return methodDeclaration;
             // Visit throws if present
             if (!!methodDeclaration.throws !== !!otherMethodDeclaration.throws) {
-                return this.abort(methodDeclaration);
+                return this.structuralMismatch('throws');
             }
             if (methodDeclaration.throws && otherMethodDeclaration.throws) {
-                // Visit each throws expression in lock step
-                if (methodDeclaration.throws.elements.length !== otherMethodDeclaration.throws.elements.length) {
-                    return this.abort(methodDeclaration);
-                }
-                for (let i = 0; i < methodDeclaration.throws.elements.length; i++) {
-                    yield this.visit(methodDeclaration.throws.elements[i].element, otherMethodDeclaration.throws.elements[i].element);
-                    if (!this.match)
-                        return methodDeclaration;
-                }
+                yield this.visitContainer(methodDeclaration.throws, otherMethodDeclaration.throws);
+                if (!this.match)
+                    return methodDeclaration;
             }
             // Visit body if present
             if (!!methodDeclaration.body !== !!otherMethodDeclaration.body) {
-                return this.abort(methodDeclaration);
+                return this.structuralMismatch('body');
             }
             if (methodDeclaration.body && otherMethodDeclaration.body) {
                 yield this.visit(methodDeclaration.body, otherMethodDeclaration.body);
@@ -2289,6 +2672,66 @@ class JavaScriptSemanticComparatorVisitor extends JavaScriptComparatorVisitor {
             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`
+     */
+    visitVoid(voidExpr, other) {
+        const _super = Object.create(null, {
+            visitVoid: { get: () => super.visitVoid }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.match)
+                return voidExpr;
+            // Check if the other is an undefined identifier
+            if (other.kind === java_1.J.Kind.Identifier) {
+                const identifier = other;
+                if (identifier.simpleName === 'undefined') {
+                    // Both evaluate to undefined, so they match
+                    return voidExpr;
+                }
+            }
+            // Otherwise delegate to parent
+            return _super.visitVoid.call(this, voidExpr, other);
+        });
+    }
+    /**
+     * Override visitLiteral to allow semantic equivalence between
+     * different numeric literal formats.
+     *
+     * Examples:
+     * - `255` matches `0xFF`
+     * - `255` matches `0o377`
+     * - `255` matches `0b11111111`
+     * - `1000` matches `1e3`
+     */
+    visitLiteral(literal, other) {
+        const _super = Object.create(null, {
+            visitLiteral: { get: () => super.visitLiteral }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.match)
+                return literal;
+            if (other.kind !== java_1.J.Kind.Literal) {
+                return yield _super.visitLiteral.call(this, literal, other);
+            }
+            const otherLiteral = other;
+            // Only compare value and type, ignoring valueSource (text representation) and unicodeEscapes
+            yield this.visitProperty(literal.value, otherLiteral.value, 'value');
+            if (!this.match)
+                return literal;
+            yield this.visitProperty(literal.type, otherLiteral.type, 'type');
+            if (!this.match)
+                return literal;
+            return literal;
+        });
+    }
 }
 exports.JavaScriptSemanticComparatorVisitor = JavaScriptSemanticComparatorVisitor;
 //# sourceMappingURL=comparator.js.map