@openrewrite/rewrite 8.67.0-20251112-150602 → 8.67.0-20251113-092819

package/dist/javascript/comparator.js

@@ -74,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)
@@ -121,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;
         });
@@ -137,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];
@@ -155,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;
@@ -181,12 +302,11 @@ 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)
@@ -209,9 +329,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     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 isRightPadded = p.kind === java_1.J.Kind.RightPadded;
             const otherWrapper = isRightPadded ? p : undefined;
@@ -222,6 +341,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
             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 {
@@ -239,9 +360,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     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 isLeftPadded = p.kind === java_1.J.Kind.LeftPadded;
             const otherWrapper = isLeftPadded ? p : undefined;
@@ -252,6 +372,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
             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 {
@@ -269,16 +391,15 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     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 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 wrappers onto both cursors, then compare each element
             const savedCursor = this.cursor;
@@ -288,9 +409,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
             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 {
@@ -1988,9 +2108,8 @@ class JavaScriptSemanticComparatorVisitor extends JavaScriptComparatorVisitor {
     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) {
+            if (!this.match)
                 return j;
-            }
             // Unwrap parentheses from both trees before comparing
             const unwrappedJ = this.unwrap(j) || j;
             const unwrappedP = this.unwrap(p) || p;
@@ -2018,11 +2137,10 @@ class JavaScriptSemanticComparatorVisitor extends JavaScriptComparatorVisitor {
      */
     visitArrowFunction(arrowFunction, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match) {
+            if (!this.match)
                 return arrowFunction;
-            }
             if (other.kind !== tree_1.JS.Kind.ArrowFunction) {
-                return this.abort(arrowFunction);
+                return this.kindMismatch();
             }
             const otherArrow = other;
             // Compare all properties reflectively except lambda (handled specially below)
@@ -2035,7 +2153,7 @@ class JavaScriptSemanticComparatorVisitor extends JavaScriptComparatorVisitor {
                 // Handle arrays
                 if (Array.isArray(jValue)) {
                     if (!Array.isArray(otherValue) || jValue.length !== otherValue.length) {
-                        return this.abort(arrowFunction);
+                        return this.arrayLengthMismatch(key);
                     }
                     for (let i = 0; i < jValue.length; i++) {
                         yield this.visitProperty(jValue[i], otherValue[i]);
@@ -2053,7 +2171,7 @@ class JavaScriptSemanticComparatorVisitor extends JavaScriptComparatorVisitor {
             const params1 = arrowFunction.lambda.parameters.parameters;
             const params2 = otherArrow.lambda.parameters.parameters;
             if (params1.length !== params2.length) {
-                return this.abort(arrowFunction);
+                return this.arrayLengthMismatch('lambda.parameters.parameters');
             }
             for (let i = 0; i < params1.length; i++) {
                 yield this.visitProperty(params1[i], params2[i]);
@@ -2087,11 +2205,10 @@ class JavaScriptSemanticComparatorVisitor extends JavaScriptComparatorVisitor {
      */
     visitLambdaParameters(parameters, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match) {
+            if (!this.match)
                 return parameters;
-            }
             if (other.kind !== java_1.J.Kind.LambdaParameters) {
-                return this.abort(parameters);
+                return this.kindMismatch();
             }
             const otherParams = other;
             // Compare all properties except 'parenthesized' using reflection
@@ -2104,7 +2221,7 @@ class JavaScriptSemanticComparatorVisitor extends JavaScriptComparatorVisitor {
                 // Handle arrays
                 if (Array.isArray(jValue)) {
                     if (!Array.isArray(otherValue) || jValue.length !== otherValue.length) {
-                        return this.abort(parameters);
+                        return this.arrayLengthMismatch(key);
                     }
                     for (let i = 0; i < jValue.length; i++) {
                         yield this.visitProperty(jValue[i], otherValue[i]);
@@ -2134,11 +2251,10 @@ class JavaScriptSemanticComparatorVisitor extends JavaScriptComparatorVisitor {
             visitPropertyAssignment: { get: () => super.visitPropertyAssignment }
         });
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match) {
+            if (!this.match)
                 return propertyAssignment;
-            }
             if (other.kind !== tree_1.JS.Kind.PropertyAssignment) {
-                return this.abort(propertyAssignment);
+                return this.kindMismatch();
             }
             const otherProp = other;
             // Extract property names for semantic comparison
@@ -2165,7 +2281,7 @@ class JavaScriptSemanticComparatorVisitor extends JavaScriptComparatorVisitor {
             }
             else {
                 // Not equivalent (e.g., { x: y })
-                return this.abort(propertyAssignment);
+                return this.structuralMismatch('initializer');
             }
         });
     }
@@ -2214,7 +2330,7 @@ class JavaScriptSemanticComparatorVisitor extends JavaScriptComparatorVisitor {
      * 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 }
         });
@@ -2228,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;
@@ -2314,13 +2430,9 @@ 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 argument length (always required)
-            if (method.arguments.elements.length !== otherMethod.arguments.elements.length) {
-                return this.abort(method);
-            }
             // 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)
@@ -2346,14 +2458,14 @@ class JavaScriptSemanticComparatorVisitor extends JavaScriptComparatorVisitor {
             // Check names unless we determined we can skip based on type FQN matching
             if (!canSkipNameCheck) {
                 if (method.name.simpleName !== otherMethod.name.simpleName) {
-                    return this.abort(method);
+                    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.abort(method);
+                        return this.typeMismatch('methodType');
                     }
                 }
                 // If neither has type, use structural comparison
@@ -2371,7 +2483,7 @@ class JavaScriptSemanticComparatorVisitor extends JavaScriptComparatorVisitor {
                         const otherFQN = java_1.Type.FullyQualified.getFullyQualifiedName(otherDeclaringType);
                         // Different declaring types = different methods, even with same name
                         if (methodFQN !== otherFQN) {
-                            return this.abort(method);
+                            return this.valueMismatch('methodType.declaringType');
                         }
                     }
                 }
@@ -2381,47 +2493,36 @@ class JavaScriptSemanticComparatorVisitor extends JavaScriptComparatorVisitor {
             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.visitRightPadded(method.select, otherMethod.select);
-                    if (!this.match) {
-                        return this.abort(method);
-                    }
+                    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.visitRightPadded(method.typeParameters.elements[i], otherMethod.typeParameters.elements[i]);
-                    if (!this.match) {
-                        return this.abort(method);
-                    }
-                }
+                yield this.visitContainerProperty('typeParameters', method.typeParameters, otherMethod.typeParameters);
+                if (!this.match)
+                    return 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 this.abort(method);
-                }
-            }
-            // Compare arguments (visit RightPadded to check for markers)
-            for (let i = 0; i < method.arguments.elements.length; i++) {
-                yield this.visitRightPadded(method.arguments.elements[i], otherMethod.arguments.elements[i]);
-                if (!this.match) {
-                    return this.abort(method);
-                }
+                if (!this.match)
+                    return method;
             }
+            // Compare arguments
+            yield this.visitContainerProperty('arguments', method.arguments, otherMethod.arguments);
+            if (!this.match)
+                return method;
             return method;
         });
     }
@@ -2441,24 +2542,24 @@ class JavaScriptSemanticComparatorVisitor extends JavaScriptComparatorVisitor {
                 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);
@@ -2473,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
             }
@@ -2505,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.visitRightPadded(variableDeclarations.variables[i], otherVariableDeclarations.variables[i]);
-                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;
         });
     }
@@ -2529,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);
@@ -2558,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
             }
@@ -2573,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.visitRightPadded(methodDeclaration.parameters.elements[i], otherMethodDeclaration.parameters.elements[i]);
-                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.visitRightPadded(methodDeclaration.throws.elements[i], otherMethodDeclaration.throws.elements[i]);
-                    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);
@@ -2624,9 +2687,8 @@ class JavaScriptSemanticComparatorVisitor extends JavaScriptComparatorVisitor {
             visitVoid: { get: () => super.visitVoid }
         });
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match) {
+            if (!this.match)
                 return voidExpr;
-            }
             // Check if the other is an undefined identifier
             if (other.kind === java_1.J.Kind.Identifier) {
                 const identifier = other;
@@ -2654,18 +2716,17 @@ class JavaScriptSemanticComparatorVisitor extends JavaScriptComparatorVisitor {
             visitLiteral: { get: () => super.visitLiteral }
         });
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match) {
+            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);
+            yield this.visitProperty(literal.value, otherLiteral.value, 'value');
             if (!this.match)
                 return literal;
-            yield this.visitProperty(literal.type, otherLiteral.type);
+            yield this.visitProperty(literal.type, otherLiteral.type, 'type');
             if (!this.match)
                 return literal;
             return literal;