@openrewrite/rewrite 8.67.0-20251104-111121 → 8.67.0-20251104-114312

package/src/javascript/comparator.ts

@@ -29,13 +29,6 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      */
     protected match: boolean = true;
 
-    /**
-     * Creates a new comparator visitor.
-     */
-    constructor() {
-        super();
-    }
-
     /**
      * Compares two AST trees.
      * 
@@ -68,6 +61,113 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
         return t;
     }
 
+    /**
+     * Generic method to visit a property value using the appropriate visitor method.
+     * This ensures wrappers (RightPadded, LeftPadded, Container) are properly tracked on the cursor.
+     *
+     * @param j The property value from the first tree
+     * @param other The corresponding property value from the second tree
+     * @returns The visited property value from the first tree
+     */
+    protected async visitProperty(j: any, other: any): Promise<any> {
+        // Handle null/undefined (but not other falsy values like 0, false, '')
+        if (j == null || other == null) {
+            if (j !== other) {
+                this.abort(j);
+            }
+            return j;
+        }
+
+        const kind = (j as any).kind;
+
+        // Check wrappers by kind
+        if (kind === J.Kind.RightPadded) {
+            return await this.visitRightPadded(j, other);
+        }
+
+        if (kind === J.Kind.LeftPadded) {
+            return await this.visitLeftPadded(j, other);
+        }
+
+        if (kind === J.Kind.Container) {
+            return await this.visitContainer(j, other);
+        }
+
+        // Check if it's a Space (skip comparison)
+        if (kind === J.Kind.Space) {
+            return j;
+        }
+
+        // Check if it's a Tree node (has a kind property with a string value)
+        if (kind !== undefined && typeof kind === 'string') {
+            // Check if it's a Type node (starts with "org.openrewrite.java.tree.JavaType$")
+            if (kind.startsWith('org.openrewrite.java.tree.JavaType$')) {
+                return await this.visitType(j, other);
+            }
+            return await this.visit(j, other);
+        }
+
+        // For primitive values, compare directly
+        if (j !== other) {
+            this.abort(j);
+        }
+        return j;
+    }
+
+    /**
+     * Generic method to visit all properties of an element, calling visitProperty for each.
+     * This automatically handles wrappers and ensures proper cursor tracking.
+     * Also checks that both elements have the same kind.
+     *
+     * @param j The element from the first tree
+     * @param other The corresponding element from the second tree
+     * @returns The visited element from the first tree
+     */
+    protected async visitElement<T extends J>(j: T, other: T): Promise<T> {
+        if (!this.match) {
+            return j;
+        }
+
+        // Check if kinds match
+        if (j.kind !== other.kind) {
+            return this.abort(j);
+        }
+
+        // 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') {
+                continue;
+            }
+
+            const jValue = (j as any)[key];
+            const otherValue = (other as any)[key];
+
+            // Handle arrays - compare element by element
+            if (Array.isArray(jValue)) {
+                if (!Array.isArray(otherValue) || jValue.length !== otherValue.length) {
+                    return this.abort(j);
+                }
+
+                for (let i = 0; i < jValue.length; i++) {
+                    await this.visitProperty(jValue[i], otherValue[i]);
+                    if (!this.match) {
+                        return j;
+                    }
+                }
+            } else {
+                // Visit the property (which will handle wrappers, trees, primitives, etc.)
+                await this.visitProperty(jValue, otherValue);
+
+                if (!this.match) {
+                    return j;
+                }
+            }
+        }
+
+        return j;
+    }
+
     override async visit<R extends J>(j: Tree, p: J, parent?: Cursor): Promise<R | undefined> {
         // If we've already found a mismatch, abort further processing
         if (!this.match) {
@@ -83,6 +183,97 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
         return super.visit(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.
+     */
+    public async visitRightPadded<T extends J | boolean>(right: J.RightPadded<T>, p: J): Promise<J.RightPadded<T>> {
+        if (!this.match) {
+            return right;
+        }
+
+        // Extract the other element if it's also a RightPadded
+        const otherElement = (p as any).kind === J.Kind.RightPadded
+            ? ((p as unknown) as J.RightPadded<T>).element
+            : p;
+
+        // Push wrapper onto cursor, then compare only the elements, not markers or spacing
+        const savedCursor = this.cursor;
+        this.cursor = new Cursor(right, this.cursor);
+        try {
+            await this.visitProperty(right.element, otherElement);
+        } finally {
+            this.cursor = savedCursor;
+        }
+
+        return right;
+    }
+
+    /**
+     * 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.
+     */
+    public async visitLeftPadded<T extends J | J.Space | number | string | boolean>(left: J.LeftPadded<T>, p: J): Promise<J.LeftPadded<T>> {
+        if (!this.match) {
+            return left;
+        }
+
+        // Extract the other element if it's also a LeftPadded
+        const otherElement = (p as any).kind === J.Kind.LeftPadded
+            ? ((p as unknown) as J.LeftPadded<T>).element
+            : p;
+
+        // Push wrapper onto cursor, then compare only the elements, not markers or spacing
+        const savedCursor = this.cursor;
+        this.cursor = new Cursor(left, this.cursor);
+        try {
+            await this.visitProperty(left.element, otherElement);
+        } finally {
+            this.cursor = savedCursor;
+        }
+
+        return left;
+    }
+
+    /**
+     * 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.
+     */
+    public async visitContainer<T extends J>(container: J.Container<T>, p: J): Promise<J.Container<T>> {
+        if (!this.match) {
+            return container;
+        }
+
+        // Extract the other elements if it's also a Container
+        const otherElements: J.RightPadded<T>[] = (p as any).kind === J.Kind.Container
+            ? ((p as unknown) as J.Container<T>).elements
+            : (p as any);
+
+        // Compare elements array length
+        if (container.elements.length !== otherElements.length) {
+            return this.abort(container);
+        }
+
+        // Push wrapper onto cursor, then compare each element
+        const savedCursor = this.cursor;
+        this.cursor = new Cursor(container, this.cursor);
+        try {
+            for (let i = 0; i < container.elements.length; i++) {
+                await this.visitProperty(container.elements[i], otherElements[i]);
+                if (!this.match) {
+                    return this.abort(container);
+                }
+            }
+        } finally {
+            this.cursor = savedCursor;
+        }
+
+        return container;
+    }
+
     /**
      * Overrides the visitBinary method to compare binary expressions.
      * 
@@ -91,21 +282,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited binary expression, or undefined if the visit was aborted
      */
     override async visitBinary(binary: J.Binary, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== J.Kind.Binary) {
-            return this.abort(binary);
-        }
-
-        const otherBinary = other as J.Binary;
-        if (binary.operator.element !== otherBinary.operator.element) {
-            return this.abort(binary);
-        }
-
-        // Visit left and right operands in lock step
-        await this.visit(binary.left, otherBinary.left);
-        if (!this.match) return this.abort(binary);
-
-        await this.visit(binary.right, otherBinary.right);
-        return binary;
+        return this.visitElement(binary, other as J.Binary);
     }
 
     /**
@@ -116,16 +293,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited identifier, or undefined if the visit was aborted
      */
     override async visitIdentifier(identifier: J.Identifier, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== J.Kind.Identifier) {
-            return this.abort(identifier);
-        }
-
-        const otherIdentifier = other as J.Identifier;
-        if (identifier.simpleName !== otherIdentifier.simpleName) {
-            return this.abort(identifier);
-        }
-
-        return identifier;
+        return this.visitElement(identifier, other as J.Identifier);
     }
 
     /**
@@ -136,16 +304,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited literal, or undefined if the visit was aborted
      */
     override async visitLiteral(literal: J.Literal, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== J.Kind.Literal) {
-            return this.abort(literal);
-        }
-
-        const otherLiteral = other as J.Literal;
-        if (literal.valueSource !== otherLiteral.valueSource) {
-            return this.abort(literal);
-        }
-
-        return literal;
+        return this.visitElement(literal, other as J.Literal);
     }
 
     /**
@@ -156,24 +315,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited block, or undefined if the visit was aborted
      */
     override async visitBlock(block: J.Block, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== J.Kind.Block) {
-            return this.abort(block);
-        }
-
-        const otherBlock = other as J.Block;
-        if (block.statements.length !== otherBlock.statements.length) {
-            return this.abort(block);
-        }
-
-        // Visit each statement in lock step
-        for (let i = 0; i < block.statements.length; i++) {
-            await this.visit(block.statements[i].element, otherBlock.statements[i].element);
-            if (!this.match) {
-                return this.abort(block);
-            }
-        }
-
-        return block;
+        return this.visitElement(block, other as J.Block);
     }
 
     /**
@@ -184,24 +326,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited compilation unit, or undefined if the visit was aborted
      */
     override async visitJsCompilationUnit(compilationUnit: JS.CompilationUnit, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== JS.Kind.CompilationUnit) {
-            return this.abort(compilationUnit);
-        }
-
-        const otherCompilationUnit = other as JS.CompilationUnit;
-        if (compilationUnit.statements.length !== otherCompilationUnit.statements.length) {
-            return this.abort(compilationUnit);
-        }
-
-        // Visit each statement in lock step
-        for (let i = 0; i < compilationUnit.statements.length; i++) {
-            await this.visit(compilationUnit.statements[i].element, otherCompilationUnit.statements[i].element);
-            if (!this.match) {
-                return this.abort(compilationUnit);
-            }
-        }
-
-        return compilationUnit;
+        return this.visitElement(compilationUnit, other as JS.CompilationUnit);
     }
 
     /**
@@ -212,20 +337,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited alias, or undefined if the visit was aborted
      */
     override async visitAlias(alias: JS.Alias, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== JS.Kind.Alias) {
-            return this.abort(alias);
-        }
-
-        const otherAlias = other as JS.Alias;
-
-        // Visit property name and alias in lock step
-        await this.visit(alias.propertyName.element, otherAlias.propertyName.element);
-        if (!this.match) {
-            return this.abort(alias);
-        }
-
-        await this.visit(alias.alias, otherAlias.alias);
-        return alias;
+        return this.visitElement(alias, other as JS.Alias);
     }
 
     /**
@@ -236,47 +348,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited arrow function, or undefined if the visit was aborted
      */
     override async visitArrowFunction(arrowFunction: JS.ArrowFunction, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== JS.Kind.ArrowFunction) {
-            return this.abort(arrowFunction);
-        }
-
-        const otherArrowFunction = other as JS.ArrowFunction;
-
-        // Compare modifiers
-        if (arrowFunction.modifiers.length !== otherArrowFunction.modifiers.length) {
-            return this.abort(arrowFunction);
-        }
-
-        // Visit modifiers in lock step
-        for (let i = 0; i < arrowFunction.modifiers.length; i++) {
-            await this.visit(arrowFunction.modifiers[i], otherArrowFunction.modifiers[i]);
-            if (!this.match) return arrowFunction;
-        }
-
-        // Visit type parameters if present
-        if (!!arrowFunction.typeParameters !== !!otherArrowFunction.typeParameters) {
-            return this.abort(arrowFunction);
-        }
-
-        if (arrowFunction.typeParameters) {
-            await this.visit(arrowFunction.typeParameters, otherArrowFunction.typeParameters!);
-            if (!this.match) return arrowFunction;
-        }
-
-        // Visit lambda
-        await this.visit(arrowFunction.lambda, otherArrowFunction.lambda);
-        if (!this.match) return arrowFunction;
-
-        // Visit return type expression if present
-        if (!!arrowFunction.returnTypeExpression !== !!otherArrowFunction.returnTypeExpression) {
-            return this.abort(arrowFunction);
-        }
-
-        if (arrowFunction.returnTypeExpression) {
-            await this.visit(arrowFunction.returnTypeExpression, otherArrowFunction.returnTypeExpression!);
-        }
-
-        return arrowFunction;
+        return this.visitElement(arrowFunction, other as JS.ArrowFunction);
     }
 
     /**
@@ -287,16 +359,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited await expression, or undefined if the visit was aborted
      */
     override async visitAwait(await_: JS.Await, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== JS.Kind.Await) {
-            return this.abort(await_);
-        }
-
-        const otherAwait = other as JS.Await;
-
-        // Visit expression
-        await this.visit(await_.expression, otherAwait.expression);
-
-        return await_;
+        return this.visitElement(await_, other as JS.Await);
     }
 
     /**
@@ -307,59 +370,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited JSX tag, or undefined if the visit was aborted
      */
     override async visitJsxTag(element: JSX.Tag, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== JS.Kind.JsxTag) {
-            return this.abort(element);
-        }
-
-        const otherElement = other as JSX.Tag;
-
-        // Visit open name
-        await this.visit(element.openName.element, otherElement.openName.element);
-        if (!this.match) return element;
-
-        // Compare attributes
-        if (element.attributes.length !== otherElement.attributes.length) {
-            return this.abort(element);
-        }
-
-        // Visit attributes in lock step
-        for (let i = 0; i < element.attributes.length; i++) {
-            await this.visit(element.attributes[i].element, otherElement.attributes[i].element);
-            if (!this.match) return element;
-        }
-
-        // Compare self-closing
-        if (!!element.selfClosing !== !!otherElement.selfClosing) {
-            return this.abort(element);
-        }
-
-        // Compare children
-        if (!!element.children !== !!otherElement.children) {
-            return this.abort(element);
-        }
-
-        if (element.children) {
-            if (element.children.length !== otherElement.children!.length) {
-                return this.abort(element);
-            }
-
-            // Visit children in lock step
-            for (let i = 0; i < element.children.length; i++) {
-                await this.visit(element.children[i], otherElement.children![i]);
-                if (!this.match) return element;
-            }
-        }
-
-        // Compare closing name
-        if (!!element.closingName !== !!otherElement.closingName) {
-            return this.abort(element);
-        }
-
-        if (element.closingName) {
-            await this.visit(element.closingName.element, otherElement.closingName!.element);
-        }
-
-        return element;
+        return this.visitElement(element, other as JSX.Tag);
     }
 
     /**
@@ -370,26 +381,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited JSX attribute, or undefined if the visit was aborted
      */
     override async visitJsxAttribute(attribute: JSX.Attribute, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== JS.Kind.JsxAttribute) {
-            return this.abort(attribute);
-        }
-
-        const otherAttribute = other as JSX.Attribute;
-
-        // Visit key
-        await this.visit(attribute.key, otherAttribute.key);
-        if (!this.match) return attribute;
-
-        // Compare value
-        if (!!attribute.value !== !!otherAttribute.value) {
-            return this.abort(attribute);
-        }
-
-        if (attribute.value) {
-            await this.visit(attribute.value.element, otherAttribute.value!.element);
-        }
-
-        return attribute;
+        return this.visitElement(attribute, other as JSX.Attribute);
     }
 
     /**
@@ -400,16 +392,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited JSX spread attribute, or undefined if the visit was aborted
      */
     override async visitJsxSpreadAttribute(spread: JSX.SpreadAttribute, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== JS.Kind.JsxSpreadAttribute) {
-            return this.abort(spread);
-        }
-
-        const otherSpread = other as JSX.SpreadAttribute;
-
-        // Visit expression
-        await this.visit(spread.expression.element, otherSpread.expression.element);
-
-        return spread;
+        return this.visitElement(spread, other as JSX.SpreadAttribute);
     }
 
     /**
@@ -420,16 +403,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited JSX expression, or undefined if the visit was aborted
      */
     override async visitJsxEmbeddedExpression(expr: JSX.EmbeddedExpression, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== JS.Kind.JsxEmbeddedExpression) {
-            return this.abort(expr);
-        }
-
-        const otherExpr = other as JSX.EmbeddedExpression;
-
-        // Visit expression
-        await this.visit(expr.expression.element, otherExpr.expression.element);
-
-        return expr;
+        return this.visitElement(expr, other as JSX.EmbeddedExpression);
     }
 
     /**
@@ -440,20 +414,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited JSX namespaced name, or undefined if the visit was aborted
      */
     override async visitJsxNamespacedName(ns: JSX.NamespacedName, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== JS.Kind.JsxNamespacedName) {
-            return this.abort(ns);
-        }
-
-        const otherNs = other as JSX.NamespacedName;
-
-        // Visit namespace
-        await this.visit(ns.namespace, otherNs.namespace);
-        if (!this.match) return ns;
-
-        // Visit name
-        await this.visit(ns.name.element, otherNs.name.element);
-
-        return ns;
+        return this.visitElement(ns, other as JSX.NamespacedName);
     }
 
     /**
@@ -464,20 +425,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited conditional type, or undefined if the visit was aborted
      */
     override async visitConditionalType(conditionalType: JS.ConditionalType, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== JS.Kind.ConditionalType) {
-            return this.abort(conditionalType);
-        }
-
-        const otherConditionalType = other as JS.ConditionalType;
-
-        // Visit check type
-        await this.visit(conditionalType.checkType, otherConditionalType.checkType);
-        if (!this.match) return conditionalType;
-
-        // Visit condition
-        await this.visit(conditionalType.condition.element, otherConditionalType.condition.element);
-
-        return conditionalType;
+        return this.visitElement(conditionalType, other as JS.ConditionalType);
     }
 
     /**
@@ -488,16 +436,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited delete expression, or undefined if the visit was aborted
      */
     override async visitDelete(delete_: JS.Delete, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== JS.Kind.Delete) {
-            return this.abort(delete_);
-        }
-
-        const otherDelete = other as JS.Delete;
-
-        // Visit expression
-        await this.visit(delete_.expression, otherDelete.expression);
-
-        return delete_;
+        return this.visitElement(delete_, other as JS.Delete);
     }
 
     /**
@@ -508,16 +447,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited expression statement, or undefined if the visit was aborted
      */
     override async visitExpressionStatement(expressionStatement: JS.ExpressionStatement, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== JS.Kind.ExpressionStatement) {
-            return this.abort(expressionStatement);
-        }
-
-        const otherExpressionStatement = other as JS.ExpressionStatement;
-
-        // Visit expression
-        await this.visit(expressionStatement.expression, otherExpressionStatement.expression);
-
-        return expressionStatement;
+        return this.visitElement(expressionStatement, other as JS.ExpressionStatement);
     }
 
     /**
@@ -528,35 +458,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited expression with type arguments, or undefined if the visit was aborted
      */
     override async visitExpressionWithTypeArguments(expressionWithTypeArguments: JS.ExpressionWithTypeArguments, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== JS.Kind.ExpressionWithTypeArguments) {
-            return this.abort(expressionWithTypeArguments);
-        }
-
-        const otherExpressionWithTypeArguments = other as JS.ExpressionWithTypeArguments;
-
-        // Visit class
-        await this.visit(expressionWithTypeArguments.clazz, otherExpressionWithTypeArguments.clazz);
-        if (!this.match) return expressionWithTypeArguments;
-
-        // Compare type arguments
-        if (!!expressionWithTypeArguments.typeArguments !== !!otherExpressionWithTypeArguments.typeArguments) {
-            return this.abort(expressionWithTypeArguments);
-        }
-
-        if (expressionWithTypeArguments.typeArguments) {
-            if (expressionWithTypeArguments.typeArguments.elements.length !== otherExpressionWithTypeArguments.typeArguments!.elements.length) {
-                return this.abort(expressionWithTypeArguments);
-            }
-
-            // Visit type arguments in lock step
-            for (let i = 0; i < expressionWithTypeArguments.typeArguments.elements.length; i++) {
-                await this.visit(expressionWithTypeArguments.typeArguments.elements[i].element, 
-                                otherExpressionWithTypeArguments.typeArguments!.elements[i].element);
-                if (!this.match) return expressionWithTypeArguments;
-            }
-        }
-
-        return expressionWithTypeArguments;
+        return this.visitElement(expressionWithTypeArguments, other as JS.ExpressionWithTypeArguments);
     }
 
     /**
@@ -567,53 +469,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited function call, or undefined if the visit was aborted
      */
     override async visitFunctionCall(functionCall: JS.FunctionCall, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== JS.Kind.FunctionCall) {
-            return this.abort(functionCall);
-        }
-
-        const otherFunctionCall = other as JS.FunctionCall;
-
-        // Compare function
-        if ((functionCall.function === undefined) !== (otherFunctionCall.function === undefined)) {
-            return this.abort(functionCall);
-        }
-
-        // Visit function if present
-        if (functionCall.function && otherFunctionCall.function) {
-            await this.visit(functionCall.function.element, otherFunctionCall.function.element);
-            if (!this.match) return functionCall;
-        }
-
-        // Compare typeParameters
-        if ((functionCall.typeParameters === undefined) !== (otherFunctionCall.typeParameters === undefined)) {
-            return this.abort(functionCall);
-        }
-
-        // Visit typeParameters if present
-        if (functionCall.typeParameters && otherFunctionCall.typeParameters) {
-            if (functionCall.typeParameters.elements.length !== otherFunctionCall.typeParameters.elements.length) {
-                return this.abort(functionCall);
-            }
-
-            // Visit each type parameter in lock step
-            for (let i = 0; i < functionCall.typeParameters.elements.length; i++) {
-                await this.visit(functionCall.typeParameters.elements[i].element, otherFunctionCall.typeParameters.elements[i].element);
-                if (!this.match) return functionCall;
-            }
-        }
-
-        // Compare arguments
-        if (functionCall.arguments.elements.length !== otherFunctionCall.arguments.elements.length) {
-            return this.abort(functionCall);
-        }
-
-        // Visit each argument in lock step
-        for (let i = 0; i < functionCall.arguments.elements.length; i++) {
-            await this.visit(functionCall.arguments.elements[i].element, otherFunctionCall.arguments.elements[i].element);
-            if (!this.match) return functionCall;
-        }
-
-        return functionCall;
+        return this.visitElement(functionCall, other as JS.FunctionCall);
     }
 
     /**
@@ -624,48 +480,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited function type, or undefined if the visit was aborted
      */
     override async visitFunctionType(functionType: JS.FunctionType, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== JS.Kind.FunctionType) {
-            return this.abort(functionType);
-        }
-
-        const otherFunctionType = other as JS.FunctionType;
-
-        // Compare constructor type
-        if (!!functionType.constructorType.element !== !!otherFunctionType.constructorType.element) {
-            return this.abort(functionType);
-        }
-
-        if (functionType.constructorType.element) {
-            if (functionType.constructorType.element !== otherFunctionType.constructorType.element) {
-                return this.abort(functionType);
-            }
-        }
-
-        // Compare type parameters
-        if (!!functionType.typeParameters !== !!otherFunctionType.typeParameters) {
-            return this.abort(functionType);
-        }
-
-        if (functionType.typeParameters) {
-            await this.visit(functionType.typeParameters, otherFunctionType.typeParameters!);
-            if (!this.match) return functionType;
-        }
-
-        // Compare parameters
-        if (functionType.parameters.elements.length !== otherFunctionType.parameters.elements.length) {
-            return this.abort(functionType);
-        }
-
-        // Visit parameters in lock step
-        for (let i = 0; i < functionType.parameters.elements.length; i++) {
-            await this.visit(functionType.parameters.elements[i].element, otherFunctionType.parameters.elements[i].element);
-            if (!this.match) return functionType;
-        }
-
-        // Compare return type
-        await this.visit(functionType.returnType.element, otherFunctionType.returnType.element);
-
-        return functionType;
+        return this.visitElement(functionType, other as JS.FunctionType);
     }
 
     /**
@@ -676,16 +491,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited infer type, or undefined if the visit was aborted
      */
     override async visitInferType(inferType: JS.InferType, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== JS.Kind.InferType) {
-            return this.abort(inferType);
-        }
-
-        const otherInferType = other as JS.InferType;
-
-        // Visit type parameter
-        await this.visit(inferType.typeParameter.element, otherInferType.typeParameter.element);
-
-        return inferType;
+        return this.visitElement(inferType, other as JS.InferType);
     }
 
     /**
@@ -696,59 +502,8 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited import type, or undefined if the visit was aborted
      */
     override async visitImportType(importType: JS.ImportType, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== JS.Kind.ImportType) {
-            return this.abort(importType);
-        }
-
-        const otherImportType = other as JS.ImportType;
-
-        // Compare has typeof
-        if (importType.hasTypeof.element !== otherImportType.hasTypeof.element) {
-            return this.abort(importType);
-        }
-
-        // Compare argument and attributes
-        if (importType.argumentAndAttributes.elements.length !== otherImportType.argumentAndAttributes.elements.length) {
-            return this.abort(importType);
-        }
-
-        // Visit argument and attributes in lock step
-        for (let i = 0; i < importType.argumentAndAttributes.elements.length; i++) {
-            await this.visit(importType.argumentAndAttributes.elements[i].element, 
-                           otherImportType.argumentAndAttributes.elements[i].element);
-            if (!this.match) return importType;
-        }
-
-        // Compare qualifier
-        if (!!importType.qualifier !== !!otherImportType.qualifier) {
-            return this.abort(importType);
-        }
-
-        if (importType.qualifier) {
-            await this.visit(importType.qualifier.element, otherImportType.qualifier!.element);
-            if (!this.match) return importType;
-        }
-
-        // Compare type arguments
-        if (!!importType.typeArguments !== !!otherImportType.typeArguments) {
-            return this.abort(importType);
-        }
-
-        if (importType.typeArguments) {
-            if (importType.typeArguments.elements.length !== otherImportType.typeArguments!.elements.length) {
-                return this.abort(importType);
-            }
-
-            // Visit type arguments in lock step
-            for (let i = 0; i < importType.typeArguments.elements.length; i++) {
-                await this.visit(importType.typeArguments.elements[i].element, 
-                               otherImportType.typeArguments!.elements[i].element);
-                if (!this.match) return importType;
-            }
-        }
-
-        return importType;
-    }
+        return this.visitElement(importType, other as JS.ImportType);
+    }
 
     /**
      * Overrides the visitImportDeclaration method to compare import declarations.
@@ -758,55 +513,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited import declaration, or undefined if the visit was aborted
      */
     override async visitImportDeclaration(jsImport: JS.Import, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== JS.Kind.Import) {
-            return this.abort(jsImport);
-        }
-
-        const otherImport = other as JS.Import;
-
-        // Compare modifiers
-        if (jsImport.modifiers.length !== otherImport.modifiers.length) {
-            return this.abort(jsImport);
-        }
-
-        // Visit each modifier in lock step
-        for (let i = 0; i < jsImport.modifiers.length; i++) {
-            await this.visit(jsImport.modifiers[i], otherImport.modifiers[i]);
-            if (!this.match) return jsImport;
-        }
-
-        // Compare import clause
-        if (!!jsImport.importClause !== !!otherImport.importClause) {
-            return this.abort(jsImport);
-        }
-
-        if (jsImport.importClause) {
-            await this.visit(jsImport.importClause, otherImport.importClause!);
-            if (!this.match) return jsImport;
-        }
-
-        // Visit module specifier
-        if (jsImport.moduleSpecifier) {
-            await this.visit(jsImport.moduleSpecifier.element, otherImport.moduleSpecifier!.element);
-            if (!this.match) return jsImport;
-        }
-
-        // Compare attributes
-        if (!!jsImport.attributes !== !!otherImport.attributes) {
-            return this.abort(jsImport);
-        }
-
-        if (jsImport.attributes) {
-            await this.visit(jsImport.attributes, otherImport.attributes!);
-        }
-
-        // Compare initializer
-        if (jsImport.initializer) {
-            await this.visit(jsImport.initializer.element, otherImport.initializer!.element);
-            if (!this.match) return jsImport;
-        }
-
-        return jsImport;
+        return this.visitElement(jsImport, other as JS.Import);
     }
 
     /**
@@ -817,32 +524,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited import clause, or undefined if the visit was aborted
      */
     override async visitImportClause(importClause: JS.ImportClause, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== JS.Kind.ImportClause) {
-            return this.abort(importClause);
-        }
-
-        const otherImportClause = other as JS.ImportClause;
-
-        // Compare name
-        if (!!importClause.name !== !!otherImportClause.name) {
-            return this.abort(importClause);
-        }
-
-        if (importClause.name) {
-            await this.visit(importClause.name.element, otherImportClause.name!.element);
-            if (!this.match) return importClause;
-        }
-
-        // Compare named bindings
-        if (!!importClause.namedBindings !== !!otherImportClause.namedBindings) {
-            return this.abort(importClause);
-        }
-
-        if (importClause.namedBindings) {
-            await this.visit(importClause.namedBindings, otherImportClause.namedBindings!);
-        }
-
-        return importClause;
+        return this.visitElement(importClause, other as JS.ImportClause);
     }
 
     /**
@@ -853,24 +535,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited named imports, or undefined if the visit was aborted
      */
     override async visitNamedImports(namedImports: JS.NamedImports, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== JS.Kind.NamedImports) {
-            return this.abort(namedImports);
-        }
-
-        const otherNamedImports = other as JS.NamedImports;
-
-        // Compare elements
-        if (namedImports.elements.elements.length !== otherNamedImports.elements.elements.length) {
-            return this.abort(namedImports);
-        }
-
-        // Visit elements in lock step
-        for (let i = 0; i < namedImports.elements.elements.length; i++) {
-            await this.visit(namedImports.elements.elements[i].element, otherNamedImports.elements.elements[i].element);
-            if (!this.match) return namedImports;
-        }
-
-        return namedImports;
+        return this.visitElement(namedImports, other as JS.NamedImports);
     }
 
     /**
@@ -881,27 +546,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited import specifier, or undefined if the visit was aborted
      */
     override async visitImportSpecifier(importSpecifier: JS.ImportSpecifier, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== JS.Kind.ImportSpecifier) {
-            return this.abort(importSpecifier);
-        }
-
-        const otherImportSpecifier = other as JS.ImportSpecifier;
-
-        // Compare import type
-        if (!!importSpecifier.importType.element !== !!otherImportSpecifier.importType.element) {
-            return this.abort(importSpecifier);
-        }
-
-        if (importSpecifier.importType.element) {
-            if (importSpecifier.importType.element !== otherImportSpecifier.importType.element) {
-                return this.abort(importSpecifier);
-            }
-        }
-
-        // Visit specifier
-        await this.visit(importSpecifier.specifier, otherImportSpecifier.specifier);
-
-        return importSpecifier;
+        return this.visitElement(importSpecifier, other as JS.ImportSpecifier);
     }
 
     /**
@@ -912,24 +557,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited import attributes, or undefined if the visit was aborted
      */
     override async visitImportAttributes(importAttributes: JS.ImportAttributes, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== JS.Kind.ImportAttributes) {
-            return this.abort(importAttributes);
-        }
-
-        const otherImportAttributes = other as JS.ImportAttributes;
-
-        // Compare elements
-        if (importAttributes.elements.elements.length !== otherImportAttributes.elements.elements.length) {
-            return this.abort(importAttributes);
-        }
-
-        // Visit elements in lock step
-        for (let i = 0; i < importAttributes.elements.elements.length; i++) {
-            await this.visit(importAttributes.elements.elements[i].element, otherImportAttributes.elements.elements[i].element);
-            if (!this.match) return importAttributes;
-        }
-
-        return importAttributes;
+        return this.visitElement(importAttributes, other as JS.ImportAttributes);
     }
 
     /**
@@ -940,28 +568,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited import type attributes, or undefined if the visit was aborted
      */
     override async visitImportTypeAttributes(importTypeAttributes: JS.ImportTypeAttributes, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== JS.Kind.ImportTypeAttributes) {
-            return this.abort(importTypeAttributes);
-        }
-
-        const otherImportTypeAttributes = other as JS.ImportTypeAttributes;
-
-        // Compare token
-        await this.visit(importTypeAttributes.token.element, otherImportTypeAttributes.token.element);
-        if (!this.match) return importTypeAttributes;
-
-        // Compare elements
-        if (importTypeAttributes.elements.elements.length !== otherImportTypeAttributes.elements.elements.length) {
-            return this.abort(importTypeAttributes);
-        }
-
-        // Visit elements in lock step
-        for (let i = 0; i < importTypeAttributes.elements.elements.length; i++) {
-            await this.visit(importTypeAttributes.elements.elements[i].element, otherImportTypeAttributes.elements.elements[i].element);
-            if (!this.match) return importTypeAttributes;
-        }
-
-        return importTypeAttributes;
+        return this.visitElement(importTypeAttributes, other as JS.ImportTypeAttributes);
     }
 
     /**
@@ -972,20 +579,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited import attribute, or undefined if the visit was aborted
      */
     override async visitImportAttribute(importAttribute: JS.ImportAttribute, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== JS.Kind.ImportAttribute) {
-            return this.abort(importAttribute);
-        }
-
-        const otherImportAttribute = other as JS.ImportAttribute;
-
-        // Visit name
-        await this.visit(importAttribute.name, otherImportAttribute.name);
-        if (!this.match) return importAttribute;
-
-        // Visit value
-        await this.visit(importAttribute.value.element, otherImportAttribute.value.element);
-
-        return importAttribute;
+        return this.visitElement(importAttribute, other as JS.ImportAttribute);
     }
 
     /**
@@ -996,25 +590,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited binary expression, or undefined if the visit was aborted
      */
     override async visitBinaryExtensions(jsBinary: JS.Binary, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== JS.Kind.Binary) {
-            return this.abort(jsBinary);
-        }
-
-        const otherBinary = other as JS.Binary;
-
-        // Visit left operand
-        await this.visit(jsBinary.left, otherBinary.left);
-        if (!this.match) return jsBinary;
-
-        // Compare operator
-        if (jsBinary.operator.element !== otherBinary.operator.element) {
-            return this.abort(jsBinary);
-        }
-
-        // Visit right operand
-        await this.visit(jsBinary.right, otherBinary.right);
-
-        return jsBinary;
+        return this.visitElement(jsBinary, other as JS.Binary);
     }
 
     /**
@@ -1025,16 +601,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited literal type, or undefined if the visit was aborted
      */
     override async visitLiteralType(literalType: JS.LiteralType, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== JS.Kind.LiteralType) {
-            return this.abort(literalType);
-        }
-
-        const otherLiteralType = other as JS.LiteralType;
-
-        // Visit literal
-        await this.visit(literalType.literal, otherLiteralType.literal);
-
-        return literalType;
+        return this.visitElement(literalType, other as JS.LiteralType);
     }
 
     /**
@@ -1045,58 +612,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited mapped type, or undefined if the visit was aborted
      */
     override async visitMappedType(mappedType: JS.MappedType, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== JS.Kind.MappedType) {
-            return this.abort(mappedType);
-        }
-
-        const otherMappedType = other as JS.MappedType;
-
-        // Compare prefix token
-        if (!!mappedType.prefixToken !== !!otherMappedType.prefixToken) {
-            return this.abort(mappedType);
-        }
-
-        if (mappedType.prefixToken) {
-            await this.visit(mappedType.prefixToken.element, otherMappedType.prefixToken!.element);
-            if (!this.match) return mappedType;
-        }
-
-        // Compare has readonly
-        if (mappedType.hasReadonly.element !== otherMappedType.hasReadonly.element) {
-            return this.abort(mappedType);
-        }
-
-        // Visit keys remapping
-        await this.visit(mappedType.keysRemapping, otherMappedType.keysRemapping);
-        if (!this.match) return mappedType;
-
-        // Compare suffix token
-        if (!!mappedType.suffixToken !== !!otherMappedType.suffixToken) {
-            return this.abort(mappedType);
-        }
-
-        if (mappedType.suffixToken) {
-            await this.visit(mappedType.suffixToken.element, otherMappedType.suffixToken!.element);
-            if (!this.match) return mappedType;
-        }
-
-        // Compare has question token
-        if (mappedType.hasQuestionToken.element !== otherMappedType.hasQuestionToken.element) {
-            return this.abort(mappedType);
-        }
-
-        // Compare value type
-        if (mappedType.valueType.elements.length !== otherMappedType.valueType.elements.length) {
-            return this.abort(mappedType);
-        }
-
-        // Visit value type elements in lock step
-        for (let i = 0; i < mappedType.valueType.elements.length; i++) {
-            await this.visit(mappedType.valueType.elements[i].element, otherMappedType.valueType.elements[i].element);
-            if (!this.match) return mappedType;
-        }
-
-        return mappedType;
+        return this.visitElement(mappedType, other as JS.MappedType);
     }
 
     /**
@@ -1107,26 +623,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited keys remapping, or undefined if the visit was aborted
      */
     override async visitMappedTypeKeysRemapping(keysRemapping: JS.MappedType.KeysRemapping, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== JS.Kind.MappedTypeKeysRemapping) {
-            return this.abort(keysRemapping);
-        }
-
-        const otherKeysRemapping = other as JS.MappedType.KeysRemapping;
-
-        // Visit type parameter
-        await this.visit(keysRemapping.typeParameter.element, otherKeysRemapping.typeParameter.element);
-        if (!this.match) return keysRemapping;
-
-        // Compare name type
-        if (!!keysRemapping.nameType !== !!otherKeysRemapping.nameType) {
-            return this.abort(keysRemapping);
-        }
-
-        if (keysRemapping.nameType) {
-            await this.visit(keysRemapping.nameType.element, otherKeysRemapping.nameType!.element);
-        }
-
-        return keysRemapping;
+        return this.visitElement(keysRemapping, other as JS.MappedType.KeysRemapping);
     }
 
     /**
@@ -1137,20 +634,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited mapped type parameter, or undefined if the visit was aborted
      */
     override async visitMappedTypeParameter(mappedTypeParameter: JS.MappedType.Parameter, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== JS.Kind.MappedTypeParameter) {
-            return this.abort(mappedTypeParameter);
-        }
-
-        const otherMappedTypeParameter = other as JS.MappedType.Parameter;
-
-        // Visit name
-        await this.visit(mappedTypeParameter.name, otherMappedTypeParameter.name);
-        if (!this.match) return mappedTypeParameter;
-
-        // Visit iterate type
-        await this.visit(mappedTypeParameter.iterateType.element, otherMappedTypeParameter.iterateType.element);
-
-        return mappedTypeParameter;
+        return this.visitElement(mappedTypeParameter, other as JS.MappedType.Parameter);
     }
 
     /**
@@ -1161,66 +645,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited object binding declarations, or undefined if the visit was aborted
      */
     override async visitObjectBindingPattern(objectBindingPattern: JS.ObjectBindingPattern, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== JS.Kind.ObjectBindingPattern) {
-            return this.abort(objectBindingPattern);
-        }
-
-        const otherObjectBindingPattern = other as JS.ObjectBindingPattern;
-
-        // Compare leading annotations
-        if (objectBindingPattern.leadingAnnotations.length !== otherObjectBindingPattern.leadingAnnotations.length) {
-            return this.abort(objectBindingPattern);
-        }
-
-        // Visit leading annotations in lock step
-        for (let i = 0; i < objectBindingPattern.leadingAnnotations.length; i++) {
-            await this.visit(objectBindingPattern.leadingAnnotations[i], otherObjectBindingPattern.leadingAnnotations[i]);
-            if (!this.match) return objectBindingPattern;
-        }
-
-        // Compare modifiers
-        if (objectBindingPattern.modifiers.length !== otherObjectBindingPattern.modifiers.length) {
-            return this.abort(objectBindingPattern);
-        }
-
-        // Visit modifiers in lock step
-        for (let i = 0; i < objectBindingPattern.modifiers.length; i++) {
-            await this.visit(objectBindingPattern.modifiers[i], otherObjectBindingPattern.modifiers[i]);
-            if (!this.match) return objectBindingPattern;
-        }
-
-        // Compare type expression
-        if (!!objectBindingPattern.typeExpression !== !!otherObjectBindingPattern.typeExpression) {
-            return this.abort(objectBindingPattern);
-        }
-
-        if (objectBindingPattern.typeExpression) {
-            await this.visit(objectBindingPattern.typeExpression, otherObjectBindingPattern.typeExpression!);
-            if (!this.match) return objectBindingPattern;
-        }
-
-        // Compare bindings
-        if (objectBindingPattern.bindings.elements.length !== otherObjectBindingPattern.bindings.elements.length) {
-            return this.abort(objectBindingPattern);
-        }
-
-        // Visit bindings in lock step
-        for (let i = 0; i < objectBindingPattern.bindings.elements.length; i++) {
-            await this.visit(objectBindingPattern.bindings.elements[i].element,
-                           otherObjectBindingPattern.bindings.elements[i].element);
-            if (!this.match) return objectBindingPattern;
-        }
-
-        // Compare initializer
-        if (!!objectBindingPattern.initializer !== !!otherObjectBindingPattern.initializer) {
-            return this.abort(objectBindingPattern);
-        }
-
-        if (objectBindingPattern.initializer) {
-            await this.visit(objectBindingPattern.initializer.element, otherObjectBindingPattern.initializer!.element);
-        }
-
-        return objectBindingPattern;
+        return this.visitElement(objectBindingPattern, other as JS.ObjectBindingPattern);
     }
 
     /**
@@ -1231,26 +656,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited property assignment, or undefined if the visit was aborted
      */
     override async visitPropertyAssignment(propertyAssignment: JS.PropertyAssignment, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== JS.Kind.PropertyAssignment) {
-            return this.abort(propertyAssignment);
-        }
-
-        const otherPropertyAssignment = other as JS.PropertyAssignment;
-
-        // Visit name
-        await this.visit(propertyAssignment.name.element, otherPropertyAssignment.name.element);
-        if (!this.match) return propertyAssignment;
-
-        // Compare initializer
-        if (!!propertyAssignment.initializer !== !!otherPropertyAssignment.initializer) {
-            return this.abort(propertyAssignment);
-        }
-
-        if (propertyAssignment.initializer) {
-            await this.visit(propertyAssignment.initializer, otherPropertyAssignment.initializer!);
-        }
-
-        return propertyAssignment;
+        return this.visitElement(propertyAssignment, other as JS.PropertyAssignment);
     }
 
     /**
@@ -1261,20 +667,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited satisfies expression, or undefined if the visit was aborted
      */
     override async visitSatisfiesExpression(satisfiesExpression: JS.SatisfiesExpression, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== JS.Kind.SatisfiesExpression) {
-            return this.abort(satisfiesExpression);
-        }
-
-        const otherSatisfiesExpression = other as JS.SatisfiesExpression;
-
-        // Visit expression
-        await this.visit(satisfiesExpression.expression, otherSatisfiesExpression.expression);
-        if (!this.match) return satisfiesExpression;
-
-        // Visit satisfies type
-        await this.visit(satisfiesExpression.satisfiesType.element, otherSatisfiesExpression.satisfiesType.element);
-
-        return satisfiesExpression;
+        return this.visitElement(satisfiesExpression, other as JS.SatisfiesExpression);
     }
 
     /**
@@ -1285,35 +678,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited scoped variable declarations, or undefined if the visit was aborted
      */
     override async visitScopedVariableDeclarations(scopedVariableDeclarations: JS.ScopedVariableDeclarations, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== JS.Kind.ScopedVariableDeclarations) {
-            return this.abort(scopedVariableDeclarations);
-        }
-
-        const otherScopedVariableDeclarations = other as JS.ScopedVariableDeclarations;
-
-        // Compare modifiers
-        if (scopedVariableDeclarations.modifiers.length !== otherScopedVariableDeclarations.modifiers.length) {
-            return this.abort(scopedVariableDeclarations);
-        }
-
-        // Visit modifiers in lock step
-        for (let i = 0; i < scopedVariableDeclarations.modifiers.length; i++) {
-            await this.visit(scopedVariableDeclarations.modifiers[i], otherScopedVariableDeclarations.modifiers[i]);
-            if (!this.match) return scopedVariableDeclarations;
-        }
-
-        // Compare variables
-        if (scopedVariableDeclarations.variables.length !== otherScopedVariableDeclarations.variables.length) {
-            return this.abort(scopedVariableDeclarations);
-        }
-
-        // Visit variables in lock step
-        for (let i = 0; i < scopedVariableDeclarations.variables.length; i++) {
-            await this.visit(scopedVariableDeclarations.variables[i].element, otherScopedVariableDeclarations.variables[i].element);
-            if (!this.match) return scopedVariableDeclarations;
-        }
-
-        return scopedVariableDeclarations;
+        return this.visitElement(scopedVariableDeclarations, other as JS.ScopedVariableDeclarations);
     }
 
     /**
@@ -1324,16 +689,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited statement expression, or undefined if the visit was aborted
      */
     override async visitStatementExpression(statementExpression: JS.StatementExpression, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== JS.Kind.StatementExpression) {
-            return this.abort(statementExpression);
-        }
-
-        const otherStatementExpression = other as JS.StatementExpression;
-
-        // Visit statement
-        await this.visit(statementExpression.statement, otherStatementExpression.statement);
-
-        return statementExpression;
+        return this.visitElement(statementExpression, other as JS.StatementExpression);
     }
 
     /**
@@ -1344,44 +700,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited tagged template expression, or undefined if the visit was aborted
      */
     override async visitTaggedTemplateExpression(taggedTemplateExpression: JS.TaggedTemplateExpression, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== JS.Kind.TaggedTemplateExpression) {
-            return this.abort(taggedTemplateExpression);
-        }
-
-        const otherTaggedTemplateExpression = other as JS.TaggedTemplateExpression;
-
-        // Compare tag
-        if (!!taggedTemplateExpression.tag !== !!otherTaggedTemplateExpression.tag) {
-            return this.abort(taggedTemplateExpression);
-        }
-
-        if (taggedTemplateExpression.tag) {
-            await this.visit(taggedTemplateExpression.tag.element, otherTaggedTemplateExpression.tag!.element);
-            if (!this.match) return taggedTemplateExpression;
-        }
-
-        // Compare type arguments
-        if (!!taggedTemplateExpression.typeArguments !== !!otherTaggedTemplateExpression.typeArguments) {
-            return this.abort(taggedTemplateExpression);
-        }
-
-        if (taggedTemplateExpression.typeArguments) {
-            if (taggedTemplateExpression.typeArguments.elements.length !== otherTaggedTemplateExpression.typeArguments!.elements.length) {
-                return this.abort(taggedTemplateExpression);
-            }
-
-            // Visit type arguments in lock step
-            for (let i = 0; i < taggedTemplateExpression.typeArguments.elements.length; i++) {
-                await this.visit(taggedTemplateExpression.typeArguments.elements[i].element, 
-                               otherTaggedTemplateExpression.typeArguments!.elements[i].element);
-                if (!this.match) return taggedTemplateExpression;
-            }
-        }
-
-        // Visit template expression
-        await this.visit(taggedTemplateExpression.templateExpression, otherTaggedTemplateExpression.templateExpression);
-
-        return taggedTemplateExpression;
+        return this.visitElement(taggedTemplateExpression, other as JS.TaggedTemplateExpression);
     }
 
     /**
@@ -1392,28 +711,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited template expression, or undefined if the visit was aborted
      */
     override async visitTemplateExpression(templateExpression: JS.TemplateExpression, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== JS.Kind.TemplateExpression) {
-            return this.abort(templateExpression);
-        }
-
-        const otherTemplateExpression = other as JS.TemplateExpression;
-
-        // Visit head
-        await this.visit(templateExpression.head, otherTemplateExpression.head);
-        if (!this.match) return templateExpression;
-
-        // Compare spans
-        if (templateExpression.spans.length !== otherTemplateExpression.spans.length) {
-            return this.abort(templateExpression);
-        }
-
-        // Visit spans in lock step
-        for (let i = 0; i < templateExpression.spans.length; i++) {
-            await this.visit(templateExpression.spans[i].element, otherTemplateExpression.spans[i].element);
-            if (!this.match) return templateExpression;
-        }
-
-        return templateExpression;
+        return this.visitElement(templateExpression, other as JS.TemplateExpression);
     }
 
     /**
@@ -1424,20 +722,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited template expression span, or undefined if the visit was aborted
      */
     override async visitTemplateExpressionSpan(span: JS.TemplateExpression.Span, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== JS.Kind.TemplateExpressionSpan) {
-            return this.abort(span);
-        }
-
-        const otherSpan = other as JS.TemplateExpression.Span;
-
-        // Visit expression
-        await this.visit(span.expression, otherSpan.expression);
-        if (!this.match) return span;
-
-        // Visit tail
-        await this.visit(span.tail, otherSpan.tail);
-
-        return span;
+        return this.visitElement(span, other as JS.TemplateExpression.Span);
     }
 
     /**
@@ -1448,24 +733,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited tuple, or undefined if the visit was aborted
      */
     override async visitTuple(tuple: JS.Tuple, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== JS.Kind.Tuple) {
-            return this.abort(tuple);
-        }
-
-        const otherTuple = other as JS.Tuple;
-
-        // Compare elements
-        if (tuple.elements.elements.length !== otherTuple.elements.elements.length) {
-            return this.abort(tuple);
-        }
-
-        // Visit elements in lock step
-        for (let i = 0; i < tuple.elements.elements.length; i++) {
-            await this.visit(tuple.elements.elements[i].element, otherTuple.elements.elements[i].element);
-            if (!this.match) return tuple;
-        }
-
-        return tuple;
+        return this.visitElement(tuple, other as JS.Tuple);
     }
 
     /**
@@ -1476,41 +744,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited type declaration, or undefined if the visit was aborted
      */
     override async visitTypeDeclaration(typeDeclaration: JS.TypeDeclaration, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== JS.Kind.TypeDeclaration) {
-            return this.abort(typeDeclaration);
-        }
-
-        const otherTypeDeclaration = other as JS.TypeDeclaration;
-
-        // Compare modifiers
-        if (typeDeclaration.modifiers.length !== otherTypeDeclaration.modifiers.length) {
-            return this.abort(typeDeclaration);
-        }
-
-        // Visit modifiers in lock step
-        for (let i = 0; i < typeDeclaration.modifiers.length; i++) {
-            await this.visit(typeDeclaration.modifiers[i], otherTypeDeclaration.modifiers[i]);
-            if (!this.match) return typeDeclaration;
-        }
-
-        // Visit name
-        await this.visit(typeDeclaration.name.element, otherTypeDeclaration.name.element);
-        if (!this.match) return typeDeclaration;
-
-        // Compare type parameters
-        if (!!typeDeclaration.typeParameters !== !!otherTypeDeclaration.typeParameters) {
-            return this.abort(typeDeclaration);
-        }
-
-        if (typeDeclaration.typeParameters) {
-            await this.visit(typeDeclaration.typeParameters, otherTypeDeclaration.typeParameters!);
-            if (!this.match) return typeDeclaration;
-        }
-
-        // Visit initializer
-        await this.visit(typeDeclaration.initializer.element, otherTypeDeclaration.initializer.element);
-
-        return typeDeclaration;
+        return this.visitElement(typeDeclaration, other as JS.TypeDeclaration);
     }
 
     /**
@@ -1521,16 +755,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited typeof expression, or undefined if the visit was aborted
      */
     override async visitTypeOf(typeOf: JS.TypeOf, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== JS.Kind.TypeOf) {
-            return this.abort(typeOf);
-        }
-
-        const otherTypeOf = other as JS.TypeOf;
-
-        // Visit expression
-        await this.visit(typeOf.expression, otherTypeOf.expression);
-
-        return typeOf;
+        return this.visitElement(typeOf, other as JS.TypeOf);
     }
 
     /**
@@ -1541,16 +766,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited type tree expression, or undefined if the visit was aborted
      */
     override async visitTypeTreeExpression(typeTreeExpression: JS.TypeTreeExpression, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== JS.Kind.TypeTreeExpression) {
-            return this.abort(typeTreeExpression);
-        }
-
-        const otherTypeTreeExpression = other as JS.TypeTreeExpression;
-
-        // Visit expression
-        await this.visit(typeTreeExpression.expression, otherTypeTreeExpression.expression);
-
-        return typeTreeExpression;
+        return this.visitElement(typeTreeExpression, other as JS.TypeTreeExpression);
     }
 
     /**
@@ -1561,18 +777,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited as expression, or undefined if the visit was aborted
      */
     override async visitAs(as_: JS.As, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== JS.Kind.As) {
-            return this.abort(as_);
-        }
-
-        const otherAs = other as JS.As;
-
-        // Visit left and right operands in lock step
-        await this.visit(as_.left.element, otherAs.left.element);
-        if (!this.match) return as_;
-
-        await this.visit(as_.right, otherAs.right);
-        return as_;
+        return this.visitElement(as_, other as JS.As);
     }
 
     /**
@@ -1583,25 +788,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited assignment operation, or undefined if the visit was aborted
      */
     override async visitAssignmentOperationExtensions(assignmentOperation: JS.AssignmentOperation, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== JS.Kind.AssignmentOperation) {
-            return this.abort(assignmentOperation);
-        }
-
-        const otherAssignmentOperation = other as JS.AssignmentOperation;
-
-        // Visit variable
-        await this.visit(assignmentOperation.variable, otherAssignmentOperation.variable);
-        if (!this.match) return assignmentOperation;
-
-        // Compare operator
-        if (assignmentOperation.operator.element !== otherAssignmentOperation.operator.element) {
-            return this.abort(assignmentOperation);
-        }
-
-        // Visit assignment
-        await this.visit(assignmentOperation.assignment, otherAssignmentOperation.assignment);
-
-        return assignmentOperation;
+        return this.visitElement(assignmentOperation, other as JS.AssignmentOperation);
     }
 
     /**
@@ -1612,21 +799,8 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited indexed access type, or undefined if the visit was aborted
      */
     override async visitIndexedAccessType(indexedAccessType: JS.IndexedAccessType, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== JS.Kind.IndexedAccessType) {
-            return this.abort(indexedAccessType);
-        }
-
-        const otherIndexedAccessType = other as JS.IndexedAccessType;
-
-        // Visit object type
-        await this.visit(indexedAccessType.objectType, otherIndexedAccessType.objectType);
-        if (!this.match) return indexedAccessType;
-
-        // Visit index type
-        await this.visit(indexedAccessType.indexType, otherIndexedAccessType.indexType);
-
-        return indexedAccessType;
-    }
+        return this.visitElement(indexedAccessType, other as JS.IndexedAccessType);
+    }
 
     /**
      * Overrides the visitIndexType method to compare index types.
@@ -1636,16 +810,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited index type, or undefined if the visit was aborted
      */
     override async visitIndexedAccessTypeIndexType(indexType: JS.IndexedAccessType.IndexType, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== JS.Kind.IndexType) {
-            return this.abort(indexType);
-        }
-
-        const otherIndexType = other as JS.IndexedAccessType.IndexType;
-
-        // Visit element
-        await this.visit(indexType.element.element, otherIndexType.element.element);
-
-        return indexType;
+        return this.visitElement(indexType, other as JS.IndexedAccessType.IndexType);
     }
 
     /**
@@ -1656,35 +821,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited type query, or undefined if the visit was aborted
      */
     override async visitTypeQuery(typeQuery: JS.TypeQuery, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== JS.Kind.TypeQuery) {
-            return this.abort(typeQuery);
-        }
-
-        const otherTypeQuery = other as JS.TypeQuery;
-
-        // Visit type expression
-        await this.visit(typeQuery.typeExpression, otherTypeQuery.typeExpression);
-        if (!this.match) return typeQuery;
-
-        // Compare type arguments
-        if (!!typeQuery.typeArguments !== !!otherTypeQuery.typeArguments) {
-            return this.abort(typeQuery);
-        }
-
-        if (typeQuery.typeArguments) {
-            if (typeQuery.typeArguments.elements.length !== otherTypeQuery.typeArguments!.elements.length) {
-                return this.abort(typeQuery);
-            }
-
-            // Visit type arguments in lock step
-            for (let i = 0; i < typeQuery.typeArguments.elements.length; i++) {
-                await this.visit(typeQuery.typeArguments.elements[i].element, 
-                               otherTypeQuery.typeArguments!.elements[i].element);
-                if (!this.match) return typeQuery;
-            }
-        }
-
-        return typeQuery;
+        return this.visitElement(typeQuery, other as JS.TypeQuery);
     }
 
     /**
@@ -1695,16 +832,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited type info, or undefined if the visit was aborted
      */
     override async visitTypeInfo(typeInfo: JS.TypeInfo, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== JS.Kind.TypeInfo) {
-            return this.abort(typeInfo);
-        }
-
-        const otherTypeInfo = other as JS.TypeInfo;
-
-        // Visit type identifier
-        await this.visit(typeInfo.typeIdentifier, otherTypeInfo.typeIdentifier);
-
-        return typeInfo;
+        return this.visitElement(typeInfo, other as JS.TypeInfo);
     }
 
     /**
@@ -1715,16 +843,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited computed property name, or undefined if the visit was aborted
      */
     override async visitComputedPropertyName(computedPropertyName: JS.ComputedPropertyName, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== JS.Kind.ComputedPropertyName) {
-            return this.abort(computedPropertyName);
-        }
-
-        const otherComputedPropertyName = other as JS.ComputedPropertyName;
-
-        // Visit expression
-        await this.visit(computedPropertyName.expression.element, otherComputedPropertyName.expression.element);
-
-        return computedPropertyName;
+        return this.visitElement(computedPropertyName, other as JS.ComputedPropertyName);
     }
 
     /**
@@ -1735,16 +854,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited type operator, or undefined if the visit was aborted
      */
     override async visitTypeOperator(typeOperator: JS.TypeOperator, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== JS.Kind.TypeOperator) {
-            return this.abort(typeOperator);
-        }
-
-        const otherTypeOperator = other as JS.TypeOperator;
-
-        // Visit expression
-        await this.visit(typeOperator.expression.element, otherTypeOperator.expression.element);
-
-        return typeOperator;
+        return this.visitElement(typeOperator, other as JS.TypeOperator);
     }
 
     /**
@@ -1755,31 +865,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited type predicate, or undefined if the visit was aborted
      */
     override async visitTypePredicate(typePredicate: JS.TypePredicate, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== JS.Kind.TypePredicate) {
-            return this.abort(typePredicate);
-        }
-
-        const otherTypePredicate = other as JS.TypePredicate;
-
-        // Compare asserts
-        if (typePredicate.asserts.element !== otherTypePredicate.asserts.element) {
-            return this.abort(typePredicate);
-        }
-
-        // Visit parameter name
-        await this.visit(typePredicate.parameterName, otherTypePredicate.parameterName);
-        if (!this.match) return typePredicate;
-
-        // Compare expression
-        if (!!typePredicate.expression !== !!otherTypePredicate.expression) {
-            return this.abort(typePredicate);
-        }
-
-        if (typePredicate.expression) {
-            await this.visit(typePredicate.expression.element, otherTypePredicate.expression!.element);
-        }
-
-        return typePredicate;
+        return this.visitElement(typePredicate, other as JS.TypePredicate);
     }
 
     /**
@@ -1790,24 +876,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited union, or undefined if the visit was aborted
      */
     override async visitUnion(union: JS.Union, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== JS.Kind.Union) {
-            return this.abort(union);
-        }
-
-        const otherUnion = other as JS.Union;
-
-        // Compare types
-        if (union.types.length !== otherUnion.types.length) {
-            return this.abort(union);
-        }
-
-        // Visit types in lock step
-        for (let i = 0; i < union.types.length; i++) {
-            await this.visit(union.types[i].element, otherUnion.types[i].element);
-            if (!this.match) return union;
-        }
-
-        return union;
+        return this.visitElement(union, other as JS.Union);
     }
 
     /**
@@ -1818,24 +887,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited intersection, or undefined if the visit was aborted
      */
     override async visitIntersection(intersection: JS.Intersection, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== JS.Kind.Intersection) {
-            return this.abort(intersection);
-        }
-
-        const otherIntersection = other as JS.Intersection;
-
-        // Compare types
-        if (intersection.types.length !== otherIntersection.types.length) {
-            return this.abort(intersection);
-        }
-
-        // Visit types in lock step
-        for (let i = 0; i < intersection.types.length; i++) {
-            await this.visit(intersection.types[i].element, otherIntersection.types[i].element);
-            if (!this.match) return intersection;
-        }
-
-        return intersection;
+        return this.visitElement(intersection, other as JS.Intersection);
     }
 
     /**
@@ -1846,27 +898,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited annotated type, or undefined if the visit was aborted
      */
     override async visitAnnotatedType(annotatedType: J.AnnotatedType, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== J.Kind.AnnotatedType) {
-            return this.abort(annotatedType);
-        }
-
-        const otherAnnotatedType = other as J.AnnotatedType;
-
-        // Compare annotations
-        if (annotatedType.annotations.length !== otherAnnotatedType.annotations.length) {
-            return this.abort(annotatedType);
-        }
-
-        // Visit each annotation in lock step
-        for (let i = 0; i < annotatedType.annotations.length; i++) {
-            await this.visit(annotatedType.annotations[i], otherAnnotatedType.annotations[i]);
-            if (!this.match) return annotatedType;
-        }
-
-        // Visit type expression
-        await this.visit(annotatedType.typeExpression, otherAnnotatedType.typeExpression);
-
-        return annotatedType;
+        return this.visitElement(annotatedType, other as J.AnnotatedType);
     }
 
     /**
@@ -1877,35 +909,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited annotation, or undefined if the visit was aborted
      */
     override async visitAnnotation(annotation: J.Annotation, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== J.Kind.Annotation) {
-            return this.abort(annotation);
-        }
-
-        const otherAnnotation = other as J.Annotation;
-
-        // Visit annotation type
-        await this.visit(annotation.annotationType, otherAnnotation.annotationType);
-        if (!this.match) return annotation;
-
-        // Compare arguments
-        if ((annotation.arguments === undefined) !== (otherAnnotation.arguments === undefined)) {
-            return this.abort(annotation);
-        }
-
-        // If both have arguments, visit them
-        if (annotation.arguments && otherAnnotation.arguments) {
-            if (annotation.arguments.elements.length !== otherAnnotation.arguments.elements.length) {
-                return this.abort(annotation);
-            }
-
-            // Visit each argument in lock step
-            for (let i = 0; i < annotation.arguments.elements.length; i++) {
-                await this.visit(annotation.arguments.elements[i].element, otherAnnotation.arguments.elements[i].element);
-                if (!this.match) return annotation;
-            }
-        }
-
-        return annotation;
+        return this.visitElement(annotation, other as J.Annotation);
     }
 
     /**
@@ -1916,20 +920,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited array access expression, or undefined if the visit was aborted
      */
     override async visitArrayAccess(arrayAccess: J.ArrayAccess, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== J.Kind.ArrayAccess) {
-            return this.abort(arrayAccess);
-        }
-
-        const otherArrayAccess = other as J.ArrayAccess;
-
-        // Visit indexed expression
-        await this.visit(arrayAccess.indexed, otherArrayAccess.indexed);
-        if (!this.match) return arrayAccess;
-
-        // Visit dimension
-        await this.visit(arrayAccess.dimension, otherArrayAccess.dimension);
-
-        return arrayAccess;
+        return this.visitElement(arrayAccess, other as J.ArrayAccess);
     }
 
     /**
@@ -1940,21 +931,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited array dimension, or undefined if the visit was aborted
      */
     override async visitArrayDimension(arrayDimension: J.ArrayDimension, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== J.Kind.ArrayDimension) {
-            return this.abort(arrayDimension);
-        }
-
-        const otherArrayDimension = other as J.ArrayDimension;
-
-        // Visit index
-        if (arrayDimension.index && otherArrayDimension.index) {
-            await this.visit(arrayDimension.index.element, otherArrayDimension.index.element);
-        } else if (arrayDimension.index !== otherArrayDimension.index) {
-            // One has an index and the other doesn't
-            return this.abort(arrayDimension);
-        }
-
-        return arrayDimension;
+        return this.visitElement(arrayDimension, other as J.ArrayDimension);
     }
 
     /**
@@ -1965,30 +942,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited array type, or undefined if the visit was aborted
      */
     override async visitArrayType(arrayType: J.ArrayType, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== J.Kind.ArrayType) {
-            return this.abort(arrayType);
-        }
-
-        const otherArrayType = other as J.ArrayType;
-
-        // Visit element type
-        await this.visit(arrayType.elementType, otherArrayType.elementType);
-        if (!this.match) return arrayType;
-
-        // Compare annotations
-        if ((arrayType.annotations?.length || 0) !== (otherArrayType.annotations?.length || 0)) {
-            return this.abort(arrayType);
-        }
-
-        // Visit annotations if they exist
-        if (arrayType.annotations && otherArrayType.annotations) {
-            for (let i = 0; i < arrayType.annotations.length; i++) {
-                await this.visit(arrayType.annotations[i], otherArrayType.annotations[i]);
-                if (!this.match) return arrayType;
-            }
-        }
-
-        return arrayType;
+        return this.visitElement(arrayType, other as J.ArrayType);
     }
 
     /**
@@ -1999,27 +953,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited assert statement, or undefined if the visit was aborted
      */
     override async visitAssert(anAssert: J.Assert, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== J.Kind.Assert) {
-            return this.abort(anAssert);
-        }
-
-        const otherAssert = other as J.Assert;
-
-        // Visit condition
-        await this.visit(anAssert.condition, otherAssert.condition);
-        if (!this.match) return anAssert;
-
-        // Compare detail
-        if ((anAssert.detail !== undefined) !== (otherAssert.detail !== undefined)) {
-            return this.abort(anAssert);
-        }
-
-        // Visit detail if it exists
-        if (anAssert.detail && otherAssert.detail) {
-            await this.visit(anAssert.detail.element, otherAssert.detail.element);
-        }
-
-        return anAssert;
+        return this.visitElement(anAssert, other as J.Assert);
     }
 
     /**
@@ -2030,25 +964,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited assignment expression, or undefined if the visit was aborted
      */
     override async visitAssignment(assignment: J.Assignment, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== J.Kind.Assignment) {
-            return this.abort(assignment);
-        }
-
-        const otherAssignment = other as J.Assignment;
-
-        // Visit variable
-        await this.visit(assignment.variable, otherAssignment.variable);
-        if (!this.match) return assignment;
-
-        // Visit assignment
-        if (assignment.assignment && otherAssignment.assignment) {
-            await this.visit(assignment.assignment.element, otherAssignment.assignment.element);
-        } else if (assignment.assignment !== otherAssignment.assignment) {
-            // One has an assignment and the other doesn't
-            return this.abort(assignment);
-        }
-
-        return assignment;
+        return this.visitElement(assignment, other as J.Assignment);
     }
 
     /**
@@ -2059,25 +975,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited assignment operation expression, or undefined if the visit was aborted
      */
     override async visitAssignmentOperation(assignOp: J.AssignmentOperation, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== J.Kind.AssignmentOperation) {
-            return this.abort(assignOp);
-        }
-
-        const otherAssignOp = other as J.AssignmentOperation;
-
-        // Visit variable
-        await this.visit(assignOp.variable, otherAssignOp.variable);
-        if (!this.match) return assignOp;
-
-        // Compare operator
-        if (assignOp.operator.element !== otherAssignOp.operator.element) {
-            return this.abort(assignOp);
-        }
-
-        // Visit assignment
-        await this.visit(assignOp.assignment, otherAssignOp.assignment);
-
-        return assignOp;
+        return this.visitElement(assignOp, other as J.AssignmentOperation);
     }
 
     /**
@@ -2088,23 +986,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited break statement, or undefined if the visit was aborted
      */
     override async visitBreak(breakStatement: J.Break, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== J.Kind.Break) {
-            return this.abort(breakStatement);
-        }
-
-        const otherBreak = other as J.Break;
-
-        // Compare label presence
-        if ((breakStatement.label !== undefined) !== (otherBreak.label !== undefined)) {
-            return this.abort(breakStatement);
-        }
-
-        // Visit label if it exists
-        if (breakStatement.label && otherBreak.label) {
-            await this.visit(breakStatement.label, otherBreak.label);
-        }
-
-        return breakStatement;
+        return this.visitElement(breakStatement, other as J.Break);
     }
 
     /**
@@ -2115,56 +997,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited case statement, or undefined if the visit was aborted
      */
     override async visitCase(aCase: J.Case, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== J.Kind.Case) {
-            return this.abort(aCase);
-        }
-
-        const otherCase = other as J.Case;
-
-        // Compare case labels
-        if (aCase.caseLabels.elements.length !== otherCase.caseLabels.elements.length) {
-            return this.abort(aCase);
-        }
-
-        // Visit each case label in lock step
-        for (let i = 0; i < aCase.caseLabels.elements.length; i++) {
-            await this.visit(aCase.caseLabels.elements[i].element, otherCase.caseLabels.elements[i].element);
-            if (!this.match) return aCase;
-        }
-
-        // Compare statements
-        if (aCase.statements.elements.length !== otherCase.statements.elements.length) {
-            return this.abort(aCase);
-        }
-
-        // Visit each statement in lock step
-        for (let i = 0; i < aCase.statements.elements.length; i++) {
-            await this.visit(aCase.statements.elements[i].element, otherCase.statements.elements[i].element);
-            if (!this.match) return aCase;
-        }
-
-        // Compare body presence
-        if ((aCase.body !== undefined) !== (otherCase.body !== undefined)) {
-            return this.abort(aCase);
-        }
-
-        // Visit body if it exists
-        if (aCase.body && otherCase.body) {
-            await this.visit(aCase.body.element, otherCase.body.element);
-            if (!this.match) return aCase;
-        }
-
-        // Compare guard presence
-        if ((aCase.guard !== undefined) !== (otherCase.guard !== undefined)) {
-            return this.abort(aCase);
-        }
-
-        // Visit guard if it exists
-        if (aCase.guard && otherCase.guard) {
-            await this.visit(aCase.guard, otherCase.guard);
-        }
-
-        return aCase;
+        return this.visitElement(aCase, other as J.Case);
     }
 
     /**
@@ -2175,129 +1008,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited class declaration, or undefined if the visit was aborted
      */
     override async visitClassDeclaration(classDecl: J.ClassDeclaration, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== J.Kind.ClassDeclaration) {
-            return this.abort(classDecl);
-        }
-
-        const otherClassDecl = other as J.ClassDeclaration;
-
-        // Compare leading annotations
-        if (classDecl.leadingAnnotations.length !== otherClassDecl.leadingAnnotations.length) {
-            return this.abort(classDecl);
-        }
-
-        // Visit each leading annotation in lock step
-        for (let i = 0; i < classDecl.leadingAnnotations.length; i++) {
-            await this.visit(classDecl.leadingAnnotations[i], otherClassDecl.leadingAnnotations[i]);
-            if (!this.match) return classDecl;
-        }
-
-        // Compare modifiers
-        if (classDecl.modifiers.length !== otherClassDecl.modifiers.length) {
-            return this.abort(classDecl);
-        }
-
-        // Visit each modifier in lock step
-        for (let i = 0; i < classDecl.modifiers.length; i++) {
-            await this.visit(classDecl.modifiers[i], otherClassDecl.modifiers[i]);
-            if (!this.match) return classDecl;
-        }
-
-        // Visit class kind
-        await this.visit(classDecl.classKind, otherClassDecl.classKind);
-        if (!this.match) return classDecl;
-
-        // Visit name
-        await this.visit(classDecl.name, otherClassDecl.name);
-        if (!this.match) return classDecl;
-
-        // Compare type parameters presence
-        if ((classDecl.typeParameters !== undefined) !== (otherClassDecl.typeParameters !== undefined)) {
-            return this.abort(classDecl);
-        }
-
-        // Visit type parameters if they exist
-        if (classDecl.typeParameters && otherClassDecl.typeParameters) {
-            if (classDecl.typeParameters.elements.length !== otherClassDecl.typeParameters.elements.length) {
-                return this.abort(classDecl);
-            }
-
-            // Visit each type parameter in lock step
-            for (let i = 0; i < classDecl.typeParameters.elements.length; i++) {
-                await this.visit(classDecl.typeParameters.elements[i].element, otherClassDecl.typeParameters.elements[i].element);
-                if (!this.match) return classDecl;
-            }
-        }
-
-        // Compare primary constructor presence
-        if ((classDecl.primaryConstructor !== undefined) !== (otherClassDecl.primaryConstructor !== undefined)) {
-            return this.abort(classDecl);
-        }
-
-        // Visit primary constructor if it exists
-        if (classDecl.primaryConstructor && otherClassDecl.primaryConstructor) {
-            if (classDecl.primaryConstructor.elements.length !== otherClassDecl.primaryConstructor.elements.length) {
-                return this.abort(classDecl);
-            }
-
-            // Visit each primary constructor element in lock step
-            for (let i = 0; i < classDecl.primaryConstructor.elements.length; i++) {
-                await this.visit(classDecl.primaryConstructor.elements[i].element, otherClassDecl.primaryConstructor.elements[i].element);
-                if (!this.match) return classDecl;
-            }
-        }
-
-        // Compare extends presence
-        if ((classDecl.extends !== undefined) !== (otherClassDecl.extends !== undefined)) {
-            return this.abort(classDecl);
-        }
-
-        // Visit extends if it exists
-        if (classDecl.extends && otherClassDecl.extends) {
-            await this.visit(classDecl.extends.element, otherClassDecl.extends.element);
-            if (!this.match) return classDecl;
-        }
-
-        // Compare implements presence
-        if ((classDecl.implements !== undefined) !== (otherClassDecl.implements !== undefined)) {
-            return this.abort(classDecl);
-        }
-
-        // Visit implements if it exists
-        if (classDecl.implements && otherClassDecl.implements) {
-            if (classDecl.implements.elements.length !== otherClassDecl.implements.elements.length) {
-                return this.abort(classDecl);
-            }
-
-            // Visit each implements element in lock step
-            for (let i = 0; i < classDecl.implements.elements.length; i++) {
-                await this.visit(classDecl.implements.elements[i].element, otherClassDecl.implements.elements[i].element);
-                if (!this.match) return classDecl;
-            }
-        }
-
-        // Compare permitting presence
-        if ((classDecl.permitting !== undefined) !== (otherClassDecl.permitting !== undefined)) {
-            return this.abort(classDecl);
-        }
-
-        // Visit permitting if it exists
-        if (classDecl.permitting && otherClassDecl.permitting) {
-            if (classDecl.permitting.elements.length !== otherClassDecl.permitting.elements.length) {
-                return this.abort(classDecl);
-            }
-
-            // Visit each permitting element in lock step
-            for (let i = 0; i < classDecl.permitting.elements.length; i++) {
-                await this.visit(classDecl.permitting.elements[i].element, otherClassDecl.permitting.elements[i].element);
-                if (!this.match) return classDecl;
-            }
-        }
-
-        // Visit body
-        await this.visit(classDecl.body, otherClassDecl.body);
-
-        return classDecl;
+        return this.visitElement(classDecl, other as J.ClassDeclaration);
     }
 
     /**
@@ -2308,24 +1019,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited class declaration kind, or undefined if the visit was aborted
      */
     override async visitClassDeclarationKind(kind: J.ClassDeclaration.Kind, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== J.Kind.ClassDeclarationKind) {
-            return this.abort(kind);
-        }
-
-        const otherKind = other as J.ClassDeclaration.Kind;
-
-        // Compare annotations
-        if (kind.annotations.length !== otherKind.annotations.length) {
-            return this.abort(kind);
-        }
-
-        // Visit each annotation in lock step
-        for (let i = 0; i < kind.annotations.length; i++) {
-            await this.visit(kind.annotations[i], otherKind.annotations[i]);
-            if (!this.match) return kind;
-        }
-
-        return kind;
+        return this.visitElement(kind, other as J.ClassDeclaration.Kind);
     }
 
     /**
@@ -2336,46 +1030,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited compilation unit, or undefined if the visit was aborted
      */
     override async visitCompilationUnit(compilationUnit: J.CompilationUnit, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== J.Kind.CompilationUnit) {
-            return this.abort(compilationUnit);
-        }
-
-        const otherCompilationUnit = other as J.CompilationUnit;
-
-        // Compare package declaration presence
-        if ((compilationUnit.packageDeclaration !== undefined) !== (otherCompilationUnit.packageDeclaration !== undefined)) {
-            return this.abort(compilationUnit);
-        }
-
-        // Visit package declaration if it exists
-        if (compilationUnit.packageDeclaration && otherCompilationUnit.packageDeclaration) {
-            await this.visit(compilationUnit.packageDeclaration.element, otherCompilationUnit.packageDeclaration.element);
-            if (!this.match) return compilationUnit;
-        }
-
-        // Compare imports
-        if (compilationUnit.imports.length !== otherCompilationUnit.imports.length) {
-            return this.abort(compilationUnit);
-        }
-
-        // Visit each import in lock step
-        for (let i = 0; i < compilationUnit.imports.length; i++) {
-            await this.visit(compilationUnit.imports[i].element, otherCompilationUnit.imports[i].element);
-            if (!this.match) return compilationUnit;
-        }
-
-        // Compare classes
-        if (compilationUnit.classes.length !== otherCompilationUnit.classes.length) {
-            return this.abort(compilationUnit);
-        }
-
-        // Visit each class in lock step
-        for (let i = 0; i < compilationUnit.classes.length; i++) {
-            await this.visit(compilationUnit.classes[i], otherCompilationUnit.classes[i]);
-            if (!this.match) return compilationUnit;
-        }
-
-        return compilationUnit;
+        return this.visitElement(compilationUnit, other as J.CompilationUnit);
     }
 
     /**
@@ -2386,23 +1041,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited continue statement, or undefined if the visit was aborted
      */
     override async visitContinue(continueStatement: J.Continue, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== J.Kind.Continue) {
-            return this.abort(continueStatement);
-        }
-
-        const otherContinue = other as J.Continue;
-
-        // Compare label presence
-        if ((continueStatement.label !== undefined) !== (otherContinue.label !== undefined)) {
-            return this.abort(continueStatement);
-        }
-
-        // Visit label if it exists
-        if (continueStatement.label && otherContinue.label) {
-            await this.visit(continueStatement.label, otherContinue.label);
-        }
-
-        return continueStatement;
+        return this.visitElement(continueStatement, other as J.Continue);
     }
 
     /**
@@ -2413,16 +1052,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited control parentheses, or undefined if the visit was aborted
      */
     override async visitControlParentheses<T extends J>(controlParens: J.ControlParentheses<T>, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== J.Kind.ControlParentheses) {
-            return this.abort(controlParens);
-        }
-
-        const otherControlParens = other as J.ControlParentheses<J>;
-
-        // Visit tree
-        await this.visit(controlParens.tree.element, otherControlParens.tree.element);
-
-        return controlParens;
+        return this.visitElement(controlParens, other as J.ControlParentheses<T>);
     }
 
     /**
@@ -2433,28 +1063,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited deconstruction pattern, or undefined if the visit was aborted
      */
     override async visitDeconstructionPattern(pattern: J.DeconstructionPattern, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== J.Kind.DeconstructionPattern) {
-            return this.abort(pattern);
-        }
-
-        const otherPattern = other as J.DeconstructionPattern;
-
-        // Visit deconstructor
-        await this.visit(pattern.deconstructor, otherPattern.deconstructor);
-        if (!this.match) return pattern;
-
-        // Compare nested elements
-        if (pattern.nested.elements.length !== otherPattern.nested.elements.length) {
-            return this.abort(pattern);
-        }
-
-        // Visit each nested element in lock step
-        for (let i = 0; i < pattern.nested.elements.length; i++) {
-            await this.visit(pattern.nested.elements[i].element, otherPattern.nested.elements[i].element);
-            if (!this.match) return pattern;
-        }
-
-        return pattern;
+        return this.visitElement(pattern, other as J.DeconstructionPattern);
     }
 
     /**
@@ -2465,20 +1074,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited do-while loop, or undefined if the visit was aborted
      */
     override async visitDoWhileLoop(doWhileLoop: J.DoWhileLoop, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== J.Kind.DoWhileLoop) {
-            return this.abort(doWhileLoop);
-        }
-
-        const otherDoWhileLoop = other as J.DoWhileLoop;
-
-        // Visit body
-        await this.visit(doWhileLoop.body.element, otherDoWhileLoop.body.element);
-        if (!this.match) return doWhileLoop;
-
-        // Visit while condition
-        await this.visit(doWhileLoop.whileCondition.element, otherDoWhileLoop.whileCondition.element);
-
-        return doWhileLoop;
+        return this.visitElement(doWhileLoop, other as J.DoWhileLoop);
     }
 
     /**
@@ -2489,13 +1085,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited empty statement, or undefined if the visit was aborted
      */
     override async visitEmpty(empty: J.Empty, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== J.Kind.Empty) {
-            return this.abort(empty);
-        }
-
-        // Empty statements have no properties to compare, so we just check the kind
-
-        return empty;
+        return this.visitElement(empty, other as J.Empty);
     }
 
     /**
@@ -2506,38 +1096,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited enum value, or undefined if the visit was aborted
      */
     override async visitEnumValue(enumValue: J.EnumValue, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== J.Kind.EnumValue) {
-            return this.abort(enumValue);
-        }
-
-        const otherEnumValue = other as J.EnumValue;
-
-        // Compare annotations
-        if (enumValue.annotations.length !== otherEnumValue.annotations.length) {
-            return this.abort(enumValue);
-        }
-
-        // Visit each annotation in lock step
-        for (let i = 0; i < enumValue.annotations.length; i++) {
-            await this.visit(enumValue.annotations[i], otherEnumValue.annotations[i]);
-            if (!this.match) return enumValue;
-        }
-
-        // Visit name
-        await this.visit(enumValue.name, otherEnumValue.name);
-        if (!this.match) return enumValue;
-
-        // Compare initializer presence
-        if ((enumValue.initializer !== undefined) !== (otherEnumValue.initializer !== undefined)) {
-            return this.abort(enumValue);
-        }
-
-        // Visit initializer if it exists
-        if (enumValue.initializer && otherEnumValue.initializer) {
-            await this.visit(enumValue.initializer, otherEnumValue.initializer);
-        }
-
-        return enumValue;
+        return this.visitElement(enumValue, other as J.EnumValue);
     }
 
     /**
@@ -2548,24 +1107,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited enum value set, or undefined if the visit was aborted
      */
     override async visitEnumValueSet(enumValueSet: J.EnumValueSet, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== J.Kind.EnumValueSet) {
-            return this.abort(enumValueSet);
-        }
-
-        const otherEnumValueSet = other as J.EnumValueSet;
-
-        // Compare enums
-        if (enumValueSet.enums.length !== otherEnumValueSet.enums.length) {
-            return this.abort(enumValueSet);
-        }
-
-        // Visit each enum in lock step
-        for (let i = 0; i < enumValueSet.enums.length; i++) {
-            await this.visit(enumValueSet.enums[i].element, otherEnumValueSet.enums[i].element);
-            if (!this.match) return enumValueSet;
-        }
-
-        return enumValueSet;
+        return this.visitElement(enumValueSet, other as J.EnumValueSet);
     }
 
     /**
@@ -2576,18 +1118,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited erroneous node, or undefined if the visit was aborted
      */
     override async visitErroneous(erroneous: J.Erroneous, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== J.Kind.Erroneous) {
-            return this.abort(erroneous);
-        }
-
-        const otherErroneous = other as J.Erroneous;
-
-        // Compare text
-        if (erroneous.text !== otherErroneous.text) {
-            return this.abort(erroneous);
-        }
-
-        return erroneous;
+        return this.visitElement(erroneous, other as J.Erroneous);
     }
 
     /**
@@ -2598,21 +1129,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited field access expression, or undefined if the visit was aborted
      */
     override async visitFieldAccess(fieldAccess: J.FieldAccess, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== J.Kind.FieldAccess) {
-            return this.abort(fieldAccess);
-        }
-
-        const otherFieldAccess = other as J.FieldAccess;
-
-        // Visit target
-        await this.visit(fieldAccess.target, otherFieldAccess.target);
-        if (!this.match) return fieldAccess;
-
-        // Visit name
-        await this.visit(fieldAccess.name.element, otherFieldAccess.name.element);
-        if (!this.match) return fieldAccess;
-
-        return fieldAccess;
+        return this.visitElement(fieldAccess, other as J.FieldAccess);
     }
 
     /**
@@ -2623,21 +1140,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited for-each loop, or undefined if the visit was aborted
      */
     override async visitForEachLoop(forEachLoop: J.ForEachLoop, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== J.Kind.ForEachLoop) {
-            return this.abort(forEachLoop);
-        }
-
-        const otherForEachLoop = other as J.ForEachLoop;
-
-        // Visit control
-        await this.visit(forEachLoop.control, otherForEachLoop.control);
-        if (!this.match) return forEachLoop;
-
-        // Visit body
-        await this.visit(forEachLoop.body.element, otherForEachLoop.body.element);
-        if (!this.match) return forEachLoop;
-
-        return forEachLoop;
+        return this.visitElement(forEachLoop, other as J.ForEachLoop);
     }
 
     /**
@@ -2648,21 +1151,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited for-each loop control, or undefined if the visit was aborted
      */
     override async visitForEachLoopControl(control: J.ForEachLoop.Control, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== J.Kind.ForEachLoopControl) {
-            return this.abort(control);
-        }
-
-        const otherControl = other as J.ForEachLoop.Control;
-
-        // Visit variable
-        await this.visit(control.variable.element, otherControl.variable.element);
-        if (!this.match) return control;
-
-        // Visit iterable
-        await this.visit(control.iterable.element, otherControl.iterable.element);
-        if (!this.match) return control;
-
-        return control;
+        return this.visitElement(control, other as J.ForEachLoop.Control);
     }
 
     /**
@@ -2673,21 +1162,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited for loop, or undefined if the visit was aborted
      */
     override async visitForLoop(forLoop: J.ForLoop, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== J.Kind.ForLoop) {
-            return this.abort(forLoop);
-        }
-
-        const otherForLoop = other as J.ForLoop;
-
-        // Visit control
-        await this.visit(forLoop.control, otherForLoop.control);
-        if (!this.match) return forLoop;
-
-        // Visit body
-        await this.visit(forLoop.body.element, otherForLoop.body.element);
-        if (!this.match) return forLoop;
-
-        return forLoop;
+        return this.visitElement(forLoop, other as J.ForLoop);
     }
 
     /**
@@ -2698,46 +1173,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited for loop control, or undefined if the visit was aborted
      */
     override async visitForLoopControl(control: J.ForLoop.Control, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== J.Kind.ForLoopControl) {
-            return this.abort(control);
-        }
-
-        const otherControl = other as J.ForLoop.Control;
-
-        // Compare init statements
-        if (control.init.length !== otherControl.init.length) {
-            return this.abort(control);
-        }
-
-        // Visit each init statement in lock step
-        for (let i = 0; i < control.init.length; i++) {
-            await this.visit(control.init[i].element, otherControl.init[i].element);
-            if (!this.match) return control;
-        }
-
-        // Compare condition
-        if ((control.condition === undefined) !== (otherControl.condition === undefined)) {
-            return this.abort(control);
-        }
-
-        // Visit condition if present
-        if (control.condition && otherControl.condition) {
-            await this.visit(control.condition.element, otherControl.condition.element);
-            if (!this.match) return control;
-        }
-
-        // Compare update statements
-        if (control.update.length !== otherControl.update.length) {
-            return this.abort(control);
-        }
-
-        // Visit each update statement in lock step
-        for (let i = 0; i < control.update.length; i++) {
-            await this.visit(control.update[i].element, otherControl.update[i].element);
-            if (!this.match) return control;
-        }
-
-        return control;
+        return this.visitElement(control, other as J.ForLoop.Control);
     }
 
     /**
@@ -2748,32 +1184,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited if statement, or undefined if the visit was aborted
      */
     override async visitIf(ifStatement: J.If, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== J.Kind.If) {
-            return this.abort(ifStatement);
-        }
-
-        const otherIfStatement = other as J.If;
-
-        // Visit condition
-        await this.visit(ifStatement.ifCondition, otherIfStatement.ifCondition);
-        if (!this.match) return ifStatement;
-
-        // Visit then part
-        await this.visit(ifStatement.thenPart.element, otherIfStatement.thenPart.element);
-        if (!this.match) return ifStatement;
-
-        // Compare else part
-        if ((ifStatement.elsePart === undefined) !== (otherIfStatement.elsePart === undefined)) {
-            return this.abort(ifStatement);
-        }
-
-        // Visit else part if present
-        if (ifStatement.elsePart && otherIfStatement.elsePart) {
-            await this.visit(ifStatement.elsePart, otherIfStatement.elsePart);
-            if (!this.match) return ifStatement;
-        }
-
-        return ifStatement;
+        return this.visitElement(ifStatement, other as J.If);
     }
 
     /**
@@ -2784,17 +1195,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited else statement, or undefined if the visit was aborted
      */
     override async visitElse(elseStatement: J.If.Else, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== J.Kind.IfElse) {
-            return this.abort(elseStatement);
-        }
-
-        const otherElseStatement = other as J.If.Else;
-
-        // Visit body
-        await this.visit(elseStatement.body.element, otherElseStatement.body.element);
-        if (!this.match) return elseStatement;
-
-        return elseStatement;
+        return this.visitElement(elseStatement, other as J.If.Else);
     }
 
     /**
@@ -2805,33 +1206,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited import statement, or undefined if the visit was aborted
      */
     override async visitImport(importStatement: J.Import, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== J.Kind.Import) {
-            return this.abort(importStatement);
-        }
-
-        const otherImportStatement = other as J.Import;
-
-        // Compare static
-        if (importStatement.static.element !== otherImportStatement.static.element) {
-            return this.abort(importStatement);
-        }
-
-        // Visit qualid
-        await this.visit(importStatement.qualid, otherImportStatement.qualid);
-        if (!this.match) return importStatement;
-
-        // Compare alias
-        if ((importStatement.alias === undefined) !== (otherImportStatement.alias === undefined)) {
-            return this.abort(importStatement);
-        }
-
-        // Visit alias if present
-        if (importStatement.alias && otherImportStatement.alias) {
-            await this.visit(importStatement.alias.element, otherImportStatement.alias.element);
-            if (!this.match) return importStatement;
-        }
-
-        return importStatement;
+        return this.visitElement(importStatement, other as J.Import);
     }
 
     /**
@@ -2842,43 +1217,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited instanceof expression, or undefined if the visit was aborted
      */
     override async visitInstanceOf(instanceOf: J.InstanceOf, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== J.Kind.InstanceOf) {
-            return this.abort(instanceOf);
-        }
-
-        const otherInstanceOf = other as J.InstanceOf;
-
-        // Visit expression
-        await this.visit(instanceOf.expression.element, otherInstanceOf.expression.element);
-        if (!this.match) return instanceOf;
-
-        // Visit class
-        await this.visit(instanceOf.class, otherInstanceOf.class);
-        if (!this.match) return instanceOf;
-
-        // Compare pattern
-        if ((instanceOf.pattern === undefined) !== (otherInstanceOf.pattern === undefined)) {
-            return this.abort(instanceOf);
-        }
-
-        // Visit pattern if present
-        if (instanceOf.pattern && otherInstanceOf.pattern) {
-            await this.visit(instanceOf.pattern, otherInstanceOf.pattern);
-            if (!this.match) return instanceOf;
-        }
-
-        // Compare modifier
-        if ((instanceOf.modifier === undefined) !== (otherInstanceOf.modifier === undefined)) {
-            return this.abort(instanceOf);
-        }
-
-        // Visit modifier if present
-        if (instanceOf.modifier && otherInstanceOf.modifier) {
-            await this.visit(instanceOf.modifier, otherInstanceOf.modifier);
-            if (!this.match) return instanceOf;
-        }
-
-        return instanceOf;
+        return this.visitElement(instanceOf, other as J.InstanceOf);
     }
 
     /**
@@ -2889,24 +1228,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited intersection type, or undefined if the visit was aborted
      */
     override async visitIntersectionType(intersectionType: J.IntersectionType, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== J.Kind.IntersectionType) {
-            return this.abort(intersectionType);
-        }
-
-        const otherIntersectionType = other as J.IntersectionType;
-
-        // Compare bounds
-        if (intersectionType.bounds.elements.length !== otherIntersectionType.bounds.elements.length) {
-            return this.abort(intersectionType);
-        }
-
-        // Visit each bound in lock step
-        for (let i = 0; i < intersectionType.bounds.elements.length; i++) {
-            await this.visit(intersectionType.bounds.elements[i].element, otherIntersectionType.bounds.elements[i].element);
-            if (!this.match) return intersectionType;
-        }
-
-        return intersectionType;
+        return this.visitElement(intersectionType, other as J.IntersectionType);
     }
 
     /**
@@ -2917,21 +1239,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited label statement, or undefined if the visit was aborted
      */
     override async visitLabel(label: J.Label, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== J.Kind.Label) {
-            return this.abort(label);
-        }
-
-        const otherLabel = other as J.Label;
-
-        // Visit label identifier
-        await this.visit(label.label.element, otherLabel.label.element);
-        if (!this.match) return label;
-
-        // Visit statement
-        await this.visit(label.statement, otherLabel.statement);
-        if (!this.match) return label;
-
-        return label;
+        return this.visitElement(label, other as J.Label);
     }
 
     /**
@@ -2942,21 +1250,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited lambda expression, or undefined if the visit was aborted
      */
     override async visitLambda(lambda: J.Lambda, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== J.Kind.Lambda) {
-            return this.abort(lambda);
-        }
-
-        const otherLambda = other as J.Lambda;
-
-        // Visit parameters
-        await this.visit(lambda.parameters, otherLambda.parameters);
-        if (!this.match) return lambda;
-
-        // Visit body
-        await this.visit(lambda.body, otherLambda.body);
-        if (!this.match) return lambda;
-
-        return lambda;
+        return this.visitElement(lambda, other as J.Lambda);
     }
 
     /**
@@ -2967,29 +1261,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited lambda parameters, or undefined if the visit was aborted
      */
     override async visitLambdaParameters(parameters: J.Lambda.Parameters, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== J.Kind.LambdaParameters) {
-            return this.abort(parameters);
-        }
-
-        const otherParameters = other as J.Lambda.Parameters;
-
-        // Compare parenthesized
-        if (parameters.parenthesized !== otherParameters.parenthesized) {
-            return this.abort(parameters);
-        }
-
-        // Compare parameters
-        if (parameters.parameters.length !== otherParameters.parameters.length) {
-            return this.abort(parameters);
-        }
-
-        // Visit each parameter in lock step
-        for (let i = 0; i < parameters.parameters.length; i++) {
-            await this.visit(parameters.parameters[i].element, otherParameters.parameters[i].element);
-            if (!this.match) return parameters;
-        }
-
-        return parameters;
+        return this.visitElement(parameters, other as J.Lambda.Parameters);
     }
 
     /**
@@ -3000,39 +1272,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited member reference, or undefined if the visit was aborted
      */
     override async visitMemberReference(memberReference: J.MemberReference, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== J.Kind.MemberReference) {
-            return this.abort(memberReference);
-        }
-
-        const otherMemberReference = other as J.MemberReference;
-
-        // Visit containing
-        await this.visit(memberReference.containing.element, otherMemberReference.containing.element);
-        if (!this.match) return memberReference;
-
-        // Compare typeParameters
-        if ((memberReference.typeParameters === undefined) !== (otherMemberReference.typeParameters === undefined)) {
-            return this.abort(memberReference);
-        }
-
-        // Visit typeParameters if present
-        if (memberReference.typeParameters && otherMemberReference.typeParameters) {
-            if (memberReference.typeParameters.elements.length !== otherMemberReference.typeParameters.elements.length) {
-                return this.abort(memberReference);
-            }
-
-            // Visit each type parameter in lock step
-            for (let i = 0; i < memberReference.typeParameters.elements.length; i++) {
-                await this.visit(memberReference.typeParameters.elements[i].element, otherMemberReference.typeParameters.elements[i].element);
-                if (!this.match) return memberReference;
-            }
-        }
-
-        // Visit reference
-        await this.visit(memberReference.reference.element, otherMemberReference.reference.element);
-        if (!this.match) return memberReference;
-
-        return memberReference;
+        return this.visitElement(memberReference, other as J.MemberReference);
     }
 
     /**
@@ -3043,123 +1283,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited method declaration, or undefined if the visit was aborted
      */
     override async visitMethodDeclaration(methodDeclaration: J.MethodDeclaration, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== J.Kind.MethodDeclaration) {
-            return this.abort(methodDeclaration);
-        }
-
-        const otherMethodDeclaration = other as J.MethodDeclaration;
-
-        // Compare leadingAnnotations
-        if (methodDeclaration.leadingAnnotations.length !== otherMethodDeclaration.leadingAnnotations.length) {
-            return this.abort(methodDeclaration);
-        }
-
-        // Visit each leading annotation in lock step
-        for (let i = 0; i < methodDeclaration.leadingAnnotations.length; i++) {
-            await this.visit(methodDeclaration.leadingAnnotations[i], otherMethodDeclaration.leadingAnnotations[i]);
-            if (!this.match) return methodDeclaration;
-        }
-
-        // Compare modifiers
-        if (methodDeclaration.modifiers.length !== otherMethodDeclaration.modifiers.length) {
-            return this.abort(methodDeclaration);
-        }
-
-        // Visit each modifier in lock step
-        for (let i = 0; i < methodDeclaration.modifiers.length; i++) {
-            await this.visit(methodDeclaration.modifiers[i], otherMethodDeclaration.modifiers[i]);
-            if (!this.match) return methodDeclaration;
-        }
-
-        // Compare typeParameters
-        if ((methodDeclaration.typeParameters === undefined) !== (otherMethodDeclaration.typeParameters === undefined)) {
-            return this.abort(methodDeclaration);
-        }
-
-        // Visit typeParameters if present
-        if (methodDeclaration.typeParameters && otherMethodDeclaration.typeParameters) {
-            await this.visit(methodDeclaration.typeParameters, otherMethodDeclaration.typeParameters);
-            if (!this.match) return methodDeclaration;
-        }
-
-        // Compare returnTypeExpression
-        if ((methodDeclaration.returnTypeExpression === undefined) !== (otherMethodDeclaration.returnTypeExpression === undefined)) {
-            return this.abort(methodDeclaration);
-        }
-
-        // Visit returnTypeExpression if present
-        if (methodDeclaration.returnTypeExpression && otherMethodDeclaration.returnTypeExpression) {
-            await this.visit(methodDeclaration.returnTypeExpression, otherMethodDeclaration.returnTypeExpression);
-            if (!this.match) return methodDeclaration;
-        }
-
-        // Compare nameAnnotations
-        if (methodDeclaration.nameAnnotations.length !== otherMethodDeclaration.nameAnnotations.length) {
-            return this.abort(methodDeclaration);
-        }
-
-        // Visit each name annotation in lock step
-        for (let i = 0; i < methodDeclaration.nameAnnotations.length; i++) {
-            await this.visit(methodDeclaration.nameAnnotations[i], otherMethodDeclaration.nameAnnotations[i]);
-            if (!this.match) return methodDeclaration;
-        }
-
-        // Visit name
-        await this.visit(methodDeclaration.name, otherMethodDeclaration.name);
-        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++) {
-            await this.visit(methodDeclaration.parameters.elements[i].element, otherMethodDeclaration.parameters.elements[i].element);
-            if (!this.match) return methodDeclaration;
-        }
-
-        // Compare throws
-        if ((methodDeclaration.throws === undefined) !== (otherMethodDeclaration.throws === undefined)) {
-            return this.abort(methodDeclaration);
-        }
-
-        // Visit throws if present
-        if (methodDeclaration.throws && otherMethodDeclaration.throws) {
-            if (methodDeclaration.throws.elements.length !== otherMethodDeclaration.throws.elements.length) {
-                return this.abort(methodDeclaration);
-            }
-
-            // Visit each throw in lock step
-            for (let i = 0; i < methodDeclaration.throws.elements.length; i++) {
-                await this.visit(methodDeclaration.throws.elements[i].element, otherMethodDeclaration.throws.elements[i].element);
-                if (!this.match) return methodDeclaration;
-            }
-        }
-
-        // Compare body
-        if ((methodDeclaration.body === undefined) !== (otherMethodDeclaration.body === undefined)) {
-            return this.abort(methodDeclaration);
-        }
-
-        // Visit body if present
-        if (methodDeclaration.body && otherMethodDeclaration.body) {
-            await this.visit(methodDeclaration.body, otherMethodDeclaration.body);
-            if (!this.match) return methodDeclaration;
-        }
-
-        // Compare defaultValue
-        if ((methodDeclaration.defaultValue === undefined) !== (otherMethodDeclaration.defaultValue === undefined)) {
-            return this.abort(methodDeclaration);
-        }
-
-        // Visit defaultValue if present
-        if (methodDeclaration.defaultValue && otherMethodDeclaration.defaultValue) {
-            await this.visit(methodDeclaration.defaultValue.element, otherMethodDeclaration.defaultValue.element);
-            if (!this.match) return methodDeclaration;
-        }
-
-        return methodDeclaration;
+        return this.visitElement(methodDeclaration, other as J.MethodDeclaration);
     }
 
     /**
@@ -3170,57 +1294,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited method invocation, or undefined if the visit was aborted
      */
     override async visitMethodInvocation(methodInvocation: J.MethodInvocation, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== J.Kind.MethodInvocation) {
-            return this.abort(methodInvocation);
-        }
-
-        const otherMethodInvocation = other as J.MethodInvocation;
-
-        // Compare select
-        if ((methodInvocation.select === undefined) !== (otherMethodInvocation.select === undefined)) {
-            return this.abort(methodInvocation);
-        }
-
-        // Visit select if present
-        if (methodInvocation.select && otherMethodInvocation.select) {
-            await this.visit(methodInvocation.select.element, otherMethodInvocation.select.element);
-            if (!this.match) return methodInvocation;
-        }
-
-        // Compare typeParameters
-        if ((methodInvocation.typeParameters === undefined) !== (otherMethodInvocation.typeParameters === undefined)) {
-            return this.abort(methodInvocation);
-        }
-
-        // Visit typeParameters if present
-        if (methodInvocation.typeParameters && otherMethodInvocation.typeParameters) {
-            if (methodInvocation.typeParameters.elements.length !== otherMethodInvocation.typeParameters.elements.length) {
-                return this.abort(methodInvocation);
-            }
-
-            // Visit each type parameter in lock step
-            for (let i = 0; i < methodInvocation.typeParameters.elements.length; i++) {
-                await this.visit(methodInvocation.typeParameters.elements[i].element, otherMethodInvocation.typeParameters.elements[i].element);
-                if (!this.match) return methodInvocation;
-            }
-        }
-
-        // Visit name
-        await this.visit(methodInvocation.name, otherMethodInvocation.name);
-        if (!this.match) return methodInvocation;
-
-        // Compare arguments
-        if (methodInvocation.arguments.elements.length !== otherMethodInvocation.arguments.elements.length) {
-            return this.abort(methodInvocation);
-        }
-
-        // Visit each argument in lock step
-        for (let i = 0; i < methodInvocation.arguments.elements.length; i++) {
-            await this.visit(methodInvocation.arguments.elements[i].element, otherMethodInvocation.arguments.elements[i].element);
-            if (!this.match) return methodInvocation;
-        }
-
-        return methodInvocation;
+        return this.visitElement(methodInvocation, other as J.MethodInvocation);
     }
 
     /**
@@ -3231,34 +1305,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited modifier, or undefined if the visit was aborted
      */
     override async visitModifier(modifier: J.Modifier, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== J.Kind.Modifier) {
-            return this.abort(modifier);
-        }
-
-        const otherModifier = other as J.Modifier;
-
-        // Compare keyword
-        if (modifier.keyword !== otherModifier.keyword) {
-            return this.abort(modifier);
-        }
-
-        // Compare type
-        if (modifier.type !== otherModifier.type) {
-            return this.abort(modifier);
-        }
-
-        // Compare annotations
-        if (modifier.annotations.length !== otherModifier.annotations.length) {
-            return this.abort(modifier);
-        }
-
-        // Visit each annotation in lock step
-        for (let i = 0; i < modifier.annotations.length; i++) {
-            await this.visit(modifier.annotations[i], otherModifier.annotations[i]);
-            if (!this.match) return modifier;
-        }
-
-        return modifier;
+        return this.visitElement(modifier, other as J.Modifier);
     }
 
     /**
@@ -3269,24 +1316,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited multi-catch expression, or undefined if the visit was aborted
      */
     override async visitMultiCatch(multiCatch: J.MultiCatch, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== J.Kind.MultiCatch) {
-            return this.abort(multiCatch);
-        }
-
-        const otherMultiCatch = other as J.MultiCatch;
-
-        // Compare alternatives
-        if (multiCatch.alternatives.length !== otherMultiCatch.alternatives.length) {
-            return this.abort(multiCatch);
-        }
-
-        // Visit each alternative in lock step
-        for (let i = 0; i < multiCatch.alternatives.length; i++) {
-            await this.visit(multiCatch.alternatives[i].element, otherMultiCatch.alternatives[i].element);
-            if (!this.match) return multiCatch;
-        }
-
-        return multiCatch;
+        return this.visitElement(multiCatch, other as J.MultiCatch);
     }
 
     /**
@@ -3297,53 +1327,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited new array expression, or undefined if the visit was aborted
      */
     override async visitNewArray(newArray: J.NewArray, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== J.Kind.NewArray) {
-            return this.abort(newArray);
-        }
-
-        const otherNewArray = other as J.NewArray;
-
-        // Compare typeExpression
-        if ((newArray.typeExpression === undefined) !== (otherNewArray.typeExpression === undefined)) {
-            return this.abort(newArray);
-        }
-
-        // Visit typeExpression if present
-        if (newArray.typeExpression && otherNewArray.typeExpression) {
-            await this.visit(newArray.typeExpression, otherNewArray.typeExpression);
-            if (!this.match) return newArray;
-        }
-
-        // Compare dimensions
-        if (newArray.dimensions.length !== otherNewArray.dimensions.length) {
-            return this.abort(newArray);
-        }
-
-        // Visit each dimension in lock step
-        for (let i = 0; i < newArray.dimensions.length; i++) {
-            await this.visit(newArray.dimensions[i], otherNewArray.dimensions[i]);
-            if (!this.match) return newArray;
-        }
-
-        // Compare initializer
-        if ((newArray.initializer === undefined) !== (otherNewArray.initializer === undefined)) {
-            return this.abort(newArray);
-        }
-
-        // Visit initializer if present
-        if (newArray.initializer && otherNewArray.initializer) {
-            if (newArray.initializer.elements.length !== otherNewArray.initializer.elements.length) {
-                return this.abort(newArray);
-            }
-
-            // Visit each initializer element in lock step
-            for (let i = 0; i < newArray.initializer.elements.length; i++) {
-                await this.visit(newArray.initializer.elements[i].element, otherNewArray.initializer.elements[i].element);
-                if (!this.match) return newArray;
-            }
-        }
-
-        return newArray;
+        return this.visitElement(newArray, other as J.NewArray);
     }
 
     /**
@@ -3354,57 +1338,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited new class expression, or undefined if the visit was aborted
      */
     override async visitNewClass(newClass: J.NewClass, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== J.Kind.NewClass) {
-            return this.abort(newClass);
-        }
-
-        const otherNewClass = other as J.NewClass;
-
-        // Compare enclosing
-        if ((newClass.enclosing === undefined) !== (otherNewClass.enclosing === undefined)) {
-            return this.abort(newClass);
-        }
-
-        // Visit enclosing if present
-        if (newClass.enclosing && otherNewClass.enclosing) {
-            await this.visit(newClass.enclosing.element, otherNewClass.enclosing.element);
-            if (!this.match) return newClass;
-        }
-
-        // Compare class
-        if ((newClass.class === undefined) !== (otherNewClass.class === undefined)) {
-            return this.abort(newClass);
-        }
-
-        // Visit class if present
-        if (newClass.class && otherNewClass.class) {
-            await this.visit(newClass.class, otherNewClass.class);
-            if (!this.match) return newClass;
-        }
-
-        // Compare arguments
-        if (newClass.arguments.elements.length !== otherNewClass.arguments.elements.length) {
-            return this.abort(newClass);
-        }
-
-        // Visit each argument in lock step
-        for (let i = 0; i < newClass.arguments.elements.length; i++) {
-            await this.visit(newClass.arguments.elements[i].element, otherNewClass.arguments.elements[i].element);
-            if (!this.match) return newClass;
-        }
-
-        // Compare body
-        if ((newClass.body === undefined) !== (otherNewClass.body === undefined)) {
-            return this.abort(newClass);
-        }
-
-        // Visit body if present
-        if (newClass.body && otherNewClass.body) {
-            await this.visit(newClass.body, otherNewClass.body);
-            if (!this.match) return newClass;
-        }
-
-        return newClass;
+        return this.visitElement(newClass, other as J.NewClass);
     }
 
     /**
@@ -3415,28 +1349,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited nullable type, or undefined if the visit was aborted
      */
     override async visitNullableType(nullableType: J.NullableType, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== J.Kind.NullableType) {
-            return this.abort(nullableType);
-        }
-
-        const otherNullableType = other as J.NullableType;
-
-        // Compare annotations
-        if (nullableType.annotations.length !== otherNullableType.annotations.length) {
-            return this.abort(nullableType);
-        }
-
-        // Visit each annotation in lock step
-        for (let i = 0; i < nullableType.annotations.length; i++) {
-            await this.visit(nullableType.annotations[i], otherNullableType.annotations[i]);
-            if (!this.match) return nullableType;
-        }
-
-        // Visit typeTree
-        await this.visit(nullableType.typeTree.element, otherNullableType.typeTree.element);
-        if (!this.match) return nullableType;
-
-        return nullableType;
+        return this.visitElement(nullableType, other as J.NullableType);
     }
 
     /**
@@ -3447,35 +1360,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited package declaration, or undefined if the visit was aborted
      */
     override async visitPackage(packageDeclaration: J.Package, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== J.Kind.Package) {
-            return this.abort(packageDeclaration);
-        }
-
-        const otherPackageDeclaration = other as J.Package;
-
-        // Visit expression
-        await this.visit(packageDeclaration.expression, otherPackageDeclaration.expression);
-        if (!this.match) return packageDeclaration;
-
-        // Compare annotations
-        if ((packageDeclaration.annotations === undefined) !== (otherPackageDeclaration.annotations === undefined)) {
-            return this.abort(packageDeclaration);
-        }
-
-        // Visit annotations if present
-        if (packageDeclaration.annotations && otherPackageDeclaration.annotations) {
-            if (packageDeclaration.annotations.length !== otherPackageDeclaration.annotations.length) {
-                return this.abort(packageDeclaration);
-            }
-
-            // Visit each annotation in lock step
-            for (let i = 0; i < packageDeclaration.annotations.length; i++) {
-                await this.visit(packageDeclaration.annotations[i], otherPackageDeclaration.annotations[i]);
-                if (!this.match) return packageDeclaration;
-            }
-        }
-
-        return packageDeclaration;
+        return this.visitElement(packageDeclaration, other as J.Package);
     }
 
     /**
@@ -3486,35 +1371,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited parameterized type, or undefined if the visit was aborted
      */
     override async visitParameterizedType(parameterizedType: J.ParameterizedType, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== J.Kind.ParameterizedType) {
-            return this.abort(parameterizedType);
-        }
-
-        const otherParameterizedType = other as J.ParameterizedType;
-
-        // Visit class
-        await this.visit(parameterizedType.class, otherParameterizedType.class);
-        if (!this.match) return parameterizedType;
-
-        // Compare typeParameters
-        if ((parameterizedType.typeParameters === undefined) !== (otherParameterizedType.typeParameters === undefined)) {
-            return this.abort(parameterizedType);
-        }
-
-        // Visit typeParameters if present
-        if (parameterizedType.typeParameters && otherParameterizedType.typeParameters) {
-            if (parameterizedType.typeParameters.elements.length !== otherParameterizedType.typeParameters.elements.length) {
-                return this.abort(parameterizedType);
-            }
-
-            // Visit each type parameter in lock step
-            for (let i = 0; i < parameterizedType.typeParameters.elements.length; i++) {
-                await this.visit(parameterizedType.typeParameters.elements[i].element, otherParameterizedType.typeParameters.elements[i].element);
-                if (!this.match) return parameterizedType;
-            }
-        }
-
-        return parameterizedType;
+        return this.visitElement(parameterizedType, other as J.ParameterizedType);
     }
 
     /**
@@ -3525,17 +1382,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited parentheses expression, or undefined if the visit was aborted
      */
     override async visitParentheses(parentheses: J.Parentheses<J>, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== J.Kind.Parentheses) {
-            return this.abort(parentheses);
-        }
-
-        const otherParentheses = other as J.Parentheses<J>;
-
-        // Visit tree
-        await this.visit(parentheses.tree.element, otherParentheses.tree.element);
-        if (!this.match) return parentheses;
-
-        return parentheses;
+        return this.visitElement(parentheses, other as J.Parentheses<J>);
     }
 
     /**
@@ -3546,28 +1393,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited parenthesized type tree, or undefined if the visit was aborted
      */
     override async visitParenthesizedTypeTree(parenthesizedTypeTree: J.ParenthesizedTypeTree, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== J.Kind.ParenthesizedTypeTree) {
-            return this.abort(parenthesizedTypeTree);
-        }
-
-        const otherParenthesizedTypeTree = other as J.ParenthesizedTypeTree;
-
-        // Compare annotations
-        if (parenthesizedTypeTree.annotations.length !== otherParenthesizedTypeTree.annotations.length) {
-            return this.abort(parenthesizedTypeTree);
-        }
-
-        // Visit each annotation in lock step
-        for (let i = 0; i < parenthesizedTypeTree.annotations.length; i++) {
-            await this.visit(parenthesizedTypeTree.annotations[i], otherParenthesizedTypeTree.annotations[i]);
-            if (!this.match) return parenthesizedTypeTree;
-        }
-
-        // Visit parenthesizedType
-        await this.visit(parenthesizedTypeTree.parenthesizedType, otherParenthesizedTypeTree.parenthesizedType);
-        if (!this.match) return parenthesizedTypeTree;
-
-        return parenthesizedTypeTree;
+        return this.visitElement(parenthesizedTypeTree, other as J.ParenthesizedTypeTree);
     }
 
     /**
@@ -3578,18 +1404,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited primitive type, or undefined if the visit was aborted
      */
     override async visitPrimitive(primitive: J.Primitive, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== J.Kind.Primitive) {
-            return this.abort(primitive);
-        }
-
-        const otherPrimitive = other as J.Primitive;
-
-        // Compare type
-        if (primitive.type.kind !== otherPrimitive.type.kind) {
-            return this.abort(primitive);
-        }
-
-        return primitive;
+        return this.visitElement(primitive, other as J.Primitive);
     }
 
     /**
@@ -3600,24 +1415,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited return statement, or undefined if the visit was aborted
      */
     override async visitReturn(returnStatement: J.Return, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== J.Kind.Return) {
-            return this.abort(returnStatement);
-        }
-
-        const otherReturnStatement = other as J.Return;
-
-        // Compare expression
-        if ((returnStatement.expression === undefined) !== (otherReturnStatement.expression === undefined)) {
-            return this.abort(returnStatement);
-        }
-
-        // Visit expression if present
-        if (returnStatement.expression && otherReturnStatement.expression) {
-            await this.visit(returnStatement.expression, otherReturnStatement.expression);
-            if (!this.match) return returnStatement;
-        }
-
-        return returnStatement;
+        return this.visitElement(returnStatement, other as J.Return);
     }
 
     /**
@@ -3628,21 +1426,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited switch statement, or undefined if the visit was aborted
      */
     override async visitSwitch(switchStatement: J.Switch, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== J.Kind.Switch) {
-            return this.abort(switchStatement);
-        }
-
-        const otherSwitchStatement = other as J.Switch;
-
-        // Visit selector
-        await this.visit(switchStatement.selector, otherSwitchStatement.selector);
-        if (!this.match) return switchStatement;
-
-        // Visit cases
-        await this.visit(switchStatement.cases, otherSwitchStatement.cases);
-        if (!this.match) return switchStatement;
-
-        return switchStatement;
+        return this.visitElement(switchStatement, other as J.Switch);
     }
 
     /**
@@ -3653,21 +1437,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited switch expression, or undefined if the visit was aborted
      */
     override async visitSwitchExpression(switchExpression: J.SwitchExpression, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== J.Kind.SwitchExpression) {
-            return this.abort(switchExpression);
-        }
-
-        const otherSwitchExpression = other as J.SwitchExpression;
-
-        // Visit selector
-        await this.visit(switchExpression.selector, otherSwitchExpression.selector);
-        if (!this.match) return switchExpression;
-
-        // Visit cases
-        await this.visit(switchExpression.cases, otherSwitchExpression.cases);
-        if (!this.match) return switchExpression;
-
-        return switchExpression;
+        return this.visitElement(switchExpression, other as J.SwitchExpression);
     }
 
     /**
@@ -3678,21 +1448,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited synchronized statement, or undefined if the visit was aborted
      */
     override async visitSynchronized(synchronizedStatement: J.Synchronized, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== J.Kind.Synchronized) {
-            return this.abort(synchronizedStatement);
-        }
-
-        const otherSynchronizedStatement = other as J.Synchronized;
-
-        // Visit lock
-        await this.visit(synchronizedStatement.lock, otherSynchronizedStatement.lock);
-        if (!this.match) return synchronizedStatement;
-
-        // Visit body
-        await this.visit(synchronizedStatement.body, otherSynchronizedStatement.body);
-        if (!this.match) return synchronizedStatement;
-
-        return synchronizedStatement;
+        return this.visitElement(synchronizedStatement, other as J.Synchronized);
     }
 
     /**
@@ -3703,25 +1459,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited ternary expression, or undefined if the visit was aborted
      */
     override async visitTernary(ternary: J.Ternary, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== J.Kind.Ternary) {
-            return this.abort(ternary);
-        }
-
-        const otherTernary = other as J.Ternary;
-
-        // Visit condition
-        await this.visit(ternary.condition, otherTernary.condition);
-        if (!this.match) return ternary;
-
-        // Visit truePart
-        await this.visit(ternary.truePart.element, otherTernary.truePart.element);
-        if (!this.match) return ternary;
-
-        // Visit falsePart
-        await this.visit(ternary.falsePart.element, otherTernary.falsePart.element);
-        if (!this.match) return ternary;
-
-        return ternary;
+        return this.visitElement(ternary, other as J.Ternary);
     }
 
     /**
@@ -3732,17 +1470,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited throw statement, or undefined if the visit was aborted
      */
     override async visitThrow(throwStatement: J.Throw, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== J.Kind.Throw) {
-            return this.abort(throwStatement);
-        }
-
-        const otherThrowStatement = other as J.Throw;
-
-        // Visit exception
-        await this.visit(throwStatement.exception, otherThrowStatement.exception);
-        if (!this.match) return throwStatement;
-
-        return throwStatement;
+        return this.visitElement(throwStatement, other as J.Throw);
     }
 
     /**
@@ -3753,57 +1481,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited try statement, or undefined if the visit was aborted
      */
     override async visitTry(tryStatement: J.Try, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== J.Kind.Try) {
-            return this.abort(tryStatement);
-        }
-
-        const otherTryStatement = other as J.Try;
-
-        // Compare resources
-        if ((tryStatement.resources === undefined) !== (otherTryStatement.resources === undefined)) {
-            return this.abort(tryStatement);
-        }
-
-        // Visit resources if present
-        if (tryStatement.resources && otherTryStatement.resources) {
-            if (tryStatement.resources.elements.length !== otherTryStatement.resources.elements.length) {
-                return this.abort(tryStatement);
-            }
-
-            // Visit each resource in lock step
-            for (let i = 0; i < tryStatement.resources.elements.length; i++) {
-                await this.visit(tryStatement.resources.elements[i].element, otherTryStatement.resources.elements[i].element);
-                if (!this.match) return tryStatement;
-            }
-        }
-
-        // Visit body
-        await this.visit(tryStatement.body, otherTryStatement.body);
-        if (!this.match) return tryStatement;
-
-        // Compare catches
-        if (tryStatement.catches.length !== otherTryStatement.catches.length) {
-            return this.abort(tryStatement);
-        }
-
-        // Visit each catch in lock step
-        for (let i = 0; i < tryStatement.catches.length; i++) {
-            await this.visit(tryStatement.catches[i], otherTryStatement.catches[i]);
-            if (!this.match) return tryStatement;
-        }
-
-        // Compare finally
-        if ((tryStatement.finally === undefined) !== (otherTryStatement.finally === undefined)) {
-            return this.abort(tryStatement);
-        }
-
-        // Visit finally if present
-        if (tryStatement.finally && otherTryStatement.finally) {
-            await this.visit(tryStatement.finally.element, otherTryStatement.finally.element);
-            if (!this.match) return tryStatement;
-        }
-
-        return tryStatement;
+        return this.visitElement(tryStatement, other as J.Try);
     }
 
     /**
@@ -3814,22 +1492,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited try resource, or undefined if the visit was aborted
      */
     override async visitTryResource(resource: J.Try.Resource, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== J.Kind.TryResource) {
-            return this.abort(resource);
-        }
-
-        const otherResource = other as J.Try.Resource;
-
-        // Visit variableDeclarations
-        await this.visit(resource.variableDeclarations, otherResource.variableDeclarations);
-        if (!this.match) return resource;
-
-        // Compare terminatedWithSemicolon
-        if (resource.terminatedWithSemicolon !== otherResource.terminatedWithSemicolon) {
-            return this.abort(resource);
-        }
-
-        return resource;
+        return this.visitElement(resource, other as J.Try.Resource);
     }
 
     /**
@@ -3840,21 +1503,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited try catch block, or undefined if the visit was aborted
      */
     override async visitTryCatch(tryCatch: J.Try.Catch, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== J.Kind.TryCatch) {
-            return this.abort(tryCatch);
-        }
-
-        const otherTryCatch = other as J.Try.Catch;
-
-        // Visit parameter
-        await this.visit(tryCatch.parameter, otherTryCatch.parameter);
-        if (!this.match) return tryCatch;
-
-        // Visit body
-        await this.visit(tryCatch.body, otherTryCatch.body);
-        if (!this.match) return tryCatch;
-
-        return tryCatch;
+        return this.visitElement(tryCatch, other as J.Try.Catch);
     }
 
     /**
@@ -3865,21 +1514,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited type cast expression, or undefined if the visit was aborted
      */
     override async visitTypeCast(typeCast: J.TypeCast, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== J.Kind.TypeCast) {
-            return this.abort(typeCast);
-        }
-
-        const otherTypeCast = other as J.TypeCast;
-
-        // Visit class
-        await this.visit(typeCast.class, otherTypeCast.class);
-        if (!this.match) return typeCast;
-
-        // Visit expression
-        await this.visit(typeCast.expression, otherTypeCast.expression);
-        if (!this.match) return typeCast;
-
-        return typeCast;
+        return this.visitElement(typeCast, other as J.TypeCast);
     }
 
     /**
@@ -3890,57 +1525,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited type parameter, or undefined if the visit was aborted
      */
     override async visitTypeParameter(typeParameter: J.TypeParameter, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== J.Kind.TypeParameter) {
-            return this.abort(typeParameter);
-        }
-
-        const otherTypeParameter = other as J.TypeParameter;
-
-        // Compare annotations
-        if (typeParameter.annotations.length !== otherTypeParameter.annotations.length) {
-            return this.abort(typeParameter);
-        }
-
-        // Visit each annotation in lock step
-        for (let i = 0; i < typeParameter.annotations.length; i++) {
-            await this.visit(typeParameter.annotations[i], otherTypeParameter.annotations[i]);
-            if (!this.match) return typeParameter;
-        }
-
-        // Compare modifiers
-        if (typeParameter.modifiers.length !== otherTypeParameter.modifiers.length) {
-            return this.abort(typeParameter);
-        }
-
-        // Visit each modifier in lock step
-        for (let i = 0; i < typeParameter.modifiers.length; i++) {
-            await this.visit(typeParameter.modifiers[i], otherTypeParameter.modifiers[i]);
-            if (!this.match) return typeParameter;
-        }
-
-        // Visit name
-        await this.visit(typeParameter.name, otherTypeParameter.name);
-        if (!this.match) return typeParameter;
-
-        // Compare bounds
-        if ((typeParameter.bounds === undefined) !== (otherTypeParameter.bounds === undefined)) {
-            return this.abort(typeParameter);
-        }
-
-        // Visit bounds if present
-        if (typeParameter.bounds && otherTypeParameter.bounds) {
-            if (typeParameter.bounds.elements.length !== otherTypeParameter.bounds.elements.length) {
-                return this.abort(typeParameter);
-            }
-
-            // Visit each bound in lock step
-            for (let i = 0; i < typeParameter.bounds.elements.length; i++) {
-                await this.visit(typeParameter.bounds.elements[i].element, otherTypeParameter.bounds.elements[i].element);
-                if (!this.match) return typeParameter;
-            }
-        }
-
-        return typeParameter;
+        return this.visitElement(typeParameter, other as J.TypeParameter);
     }
 
     /**
@@ -3951,35 +1536,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited type parameters, or undefined if the visit was aborted
      */
     override async visitTypeParameters(typeParameters: J.TypeParameters, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== J.Kind.TypeParameters) {
-            return this.abort(typeParameters);
-        }
-
-        const otherTypeParameters = other as J.TypeParameters;
-
-        // Compare annotations
-        if (typeParameters.annotations.length !== otherTypeParameters.annotations.length) {
-            return this.abort(typeParameters);
-        }
-
-        // Visit each annotation in lock step
-        for (let i = 0; i < typeParameters.annotations.length; i++) {
-            await this.visit(typeParameters.annotations[i], otherTypeParameters.annotations[i]);
-            if (!this.match) return typeParameters;
-        }
-
-        // Compare typeParameters
-        if (typeParameters.typeParameters.length !== otherTypeParameters.typeParameters.length) {
-            return this.abort(typeParameters);
-        }
-
-        // Visit each type parameter in lock step
-        for (let i = 0; i < typeParameters.typeParameters.length; i++) {
-            await this.visit(typeParameters.typeParameters[i].element, otherTypeParameters.typeParameters[i].element);
-            if (!this.match) return typeParameters;
-        }
-
-        return typeParameters;
+        return this.visitElement(typeParameters, other as J.TypeParameters);
     }
 
     /**
@@ -3990,22 +1547,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited unary expression, or undefined if the visit was aborted
      */
     override async visitUnary(unary: J.Unary, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== J.Kind.Unary) {
-            return this.abort(unary);
-        }
-
-        const otherUnary = other as J.Unary;
-
-        // Compare operator
-        if (unary.operator.element !== otherUnary.operator.element) {
-            return this.abort(unary);
-        }
-
-        // Visit expression
-        await this.visit(unary.expression, otherUnary.expression);
-        if (!this.match) return unary;
-
-        return unary;
+        return this.visitElement(unary, other as J.Unary);
     }
 
     /**
@@ -4016,17 +1558,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited unknown node, or undefined if the visit was aborted
      */
     override async visitUnknown(unknown: J.Unknown, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== J.Kind.Unknown) {
-            return this.abort(unknown);
-        }
-
-        const otherUnknown = other as J.Unknown;
-
-        // Visit source
-        await this.visit(unknown.source, otherUnknown.source);
-        if (!this.match) return unknown;
-
-        return unknown;
+        return this.visitElement(unknown, other as J.Unknown);
     }
 
     /**
@@ -4037,18 +1569,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited unknown source, or undefined if the visit was aborted
      */
     override async visitUnknownSource(unknownSource: J.UnknownSource, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== J.Kind.UnknownSource) {
-            return this.abort(unknownSource);
-        }
-
-        const otherUnknownSource = other as J.UnknownSource;
-
-        // Compare text
-        if (unknownSource.text !== otherUnknownSource.text) {
-            return this.abort(unknownSource);
-        }
-
-        return unknownSource;
+        return this.visitElement(unknownSource, other as J.UnknownSource);
     }
 
     /**
@@ -4059,62 +1580,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited variable declarations, or undefined if the visit was aborted
      */
     override async visitVariableDeclarations(variableDeclarations: J.VariableDeclarations, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== J.Kind.VariableDeclarations) {
-            return this.abort(variableDeclarations);
-        }
-
-        const otherVariableDeclarations = other as J.VariableDeclarations;
-
-        // Compare leadingAnnotations
-        if (variableDeclarations.leadingAnnotations.length !== otherVariableDeclarations.leadingAnnotations.length) {
-            return this.abort(variableDeclarations);
-        }
-
-        // Visit each leading annotation in lock step
-        for (let i = 0; i < variableDeclarations.leadingAnnotations.length; i++) {
-            await this.visit(variableDeclarations.leadingAnnotations[i], otherVariableDeclarations.leadingAnnotations[i]);
-            if (!this.match) return variableDeclarations;
-        }
-
-        // Compare modifiers
-        if (variableDeclarations.modifiers.length !== otherVariableDeclarations.modifiers.length) {
-            return this.abort(variableDeclarations);
-        }
-
-        // Visit each modifier in lock step
-        for (let i = 0; i < variableDeclarations.modifiers.length; i++) {
-            await this.visit(variableDeclarations.modifiers[i], otherVariableDeclarations.modifiers[i]);
-            if (!this.match) return variableDeclarations;
-        }
-
-        // Compare typeExpression
-        if ((variableDeclarations.typeExpression === undefined) !== (otherVariableDeclarations.typeExpression === undefined)) {
-            return this.abort(variableDeclarations);
-        }
-
-        // Visit typeExpression if present
-        if (variableDeclarations.typeExpression && otherVariableDeclarations.typeExpression) {
-            await this.visit(variableDeclarations.typeExpression, otherVariableDeclarations.typeExpression);
-            if (!this.match) return variableDeclarations;
-        }
-
-        // Compare varargs
-        if ((variableDeclarations.varargs === undefined) !== (otherVariableDeclarations.varargs === undefined)) {
-            return this.abort(variableDeclarations);
-        }
-
-        // 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++) {
-            await this.visit(variableDeclarations.variables[i].element, otherVariableDeclarations.variables[i].element);
-            if (!this.match) return variableDeclarations;
-        }
-
-        return variableDeclarations;
+        return this.visitElement(variableDeclarations, other as J.VariableDeclarations);
     }
 
     /**
@@ -4125,33 +1591,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited variable declaration, or undefined if the visit was aborted
      */
     override async visitVariable(variable: J.VariableDeclarations.NamedVariable, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== J.Kind.NamedVariable) {
-            return this.abort(variable);
-        }
-
-        const otherVariable = other as J.VariableDeclarations.NamedVariable;
-
-        // Visit name
-        await this.visit(variable.name, otherVariable.name);
-        if (!this.match) return variable;
-
-        // Compare dimensionsAfterName
-        if (variable.dimensionsAfterName.length !== otherVariable.dimensionsAfterName.length) {
-            return this.abort(variable);
-        }
-
-        // Compare initializer
-        if ((variable.initializer === undefined) !== (otherVariable.initializer === undefined)) {
-            return this.abort(variable);
-        }
-
-        // Visit initializer if present
-        if (variable.initializer && otherVariable.initializer) {
-            await this.visit(variable.initializer.element, otherVariable.initializer.element);
-            if (!this.match) return variable;
-        }
-
-        return variable;
+        return this.visitElement(variable, other as J.VariableDeclarations.NamedVariable);
     }
 
     /**
@@ -4162,21 +1602,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited while loop, or undefined if the visit was aborted
      */
     override async visitWhileLoop(whileLoop: J.WhileLoop, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== J.Kind.WhileLoop) {
-            return this.abort(whileLoop);
-        }
-
-        const otherWhileLoop = other as J.WhileLoop;
-
-        // Visit condition
-        await this.visit(whileLoop.condition, otherWhileLoop.condition);
-        if (!this.match) return whileLoop;
-
-        // Visit body
-        await this.visit(whileLoop.body.element, otherWhileLoop.body.element);
-        if (!this.match) return whileLoop;
-
-        return whileLoop;
+        return this.visitElement(whileLoop, other as J.WhileLoop);
     }
 
     /**
@@ -4187,36 +1613,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited wildcard, or undefined if the visit was aborted
      */
     override async visitWildcard(wildcard: J.Wildcard, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== J.Kind.Wildcard) {
-            return this.abort(wildcard);
-        }
-
-        const otherWildcard = other as J.Wildcard;
-
-        // Compare bound
-        if ((wildcard.bound === undefined) !== (otherWildcard.bound === undefined)) {
-            return this.abort(wildcard);
-        }
-
-        // Compare bound if present
-        if (wildcard.bound && otherWildcard.bound) {
-            if (wildcard.bound.element !== otherWildcard.bound.element) {
-                return this.abort(wildcard);
-            }
-        }
-
-        // Compare boundedType
-        if ((wildcard.boundedType === undefined) !== (otherWildcard.boundedType === undefined)) {
-            return this.abort(wildcard);
-        }
-
-        // Visit boundedType if present
-        if (wildcard.boundedType && otherWildcard.boundedType) {
-            await this.visit(wildcard.boundedType, otherWildcard.boundedType);
-            if (!this.match) return wildcard;
-        }
-
-        return wildcard;
+        return this.visitElement(wildcard, other as J.Wildcard);
     }
 
     /**
@@ -4227,22 +1624,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited yield statement, or undefined if the visit was aborted
      */
     override async visitYield(yieldStatement: J.Yield, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== J.Kind.Yield) {
-            return this.abort(yieldStatement);
-        }
-
-        const otherYieldStatement = other as J.Yield;
-
-        // Compare implicit
-        if (yieldStatement.implicit !== otherYieldStatement.implicit) {
-            return this.abort(yieldStatement);
-        }
-
-        // Visit value
-        await this.visit(yieldStatement.value, otherYieldStatement.value);
-        if (!this.match) return yieldStatement;
-
-        return yieldStatement;
+        return this.visitElement(yieldStatement, other as J.Yield);
     }
 
     /**
@@ -4253,16 +1635,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited void expression, or undefined if the visit was aborted
      */
     override async visitVoid(void_: JS.Void, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== JS.Kind.Void) {
-            return this.abort(void_);
-        }
-
-        const otherVoid = other as JS.Void;
-
-        // Visit expression
-        await this.visit(void_.expression, otherVoid.expression);
-
-        return void_;
+        return this.visitElement(void_, other as JS.Void);
     }
 
     /**
@@ -4273,20 +1646,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited with statement, or undefined if the visit was aborted
      */
     override async visitWithStatement(withStatement: JS.WithStatement, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== JS.Kind.WithStatement) {
-            return this.abort(withStatement);
-        }
-
-        const otherWithStatement = other as JS.WithStatement;
-
-        // Visit expression
-        await this.visit(withStatement.expression, otherWithStatement.expression);
-        if (!this.match) return withStatement;
-
-        // Visit body
-        await this.visit(withStatement.body.element, otherWithStatement.body.element);
-
-        return withStatement;
+        return this.visitElement(withStatement, other as JS.WithStatement);
     }
 
     /**
@@ -4297,39 +1657,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited index signature declaration, or undefined if the visit was aborted
      */
     override async visitIndexSignatureDeclaration(indexSignatureDeclaration: JS.IndexSignatureDeclaration, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== JS.Kind.IndexSignatureDeclaration) {
-            return this.abort(indexSignatureDeclaration);
-        }
-
-        const otherIndexSignatureDeclaration = other as JS.IndexSignatureDeclaration;
-
-        // Compare modifiers
-        if (indexSignatureDeclaration.modifiers.length !== otherIndexSignatureDeclaration.modifiers.length) {
-            return this.abort(indexSignatureDeclaration);
-        }
-
-        // Visit modifiers in lock step
-        for (let i = 0; i < indexSignatureDeclaration.modifiers.length; i++) {
-            await this.visit(indexSignatureDeclaration.modifiers[i], otherIndexSignatureDeclaration.modifiers[i]);
-            if (!this.match) return indexSignatureDeclaration;
-        }
-
-        // Compare parameters
-        if (indexSignatureDeclaration.parameters.elements.length !== otherIndexSignatureDeclaration.parameters.elements.length) {
-            return this.abort(indexSignatureDeclaration);
-        }
-
-        // Visit parameters in lock step
-        for (let i = 0; i < indexSignatureDeclaration.parameters.elements.length; i++) {
-            await this.visit(indexSignatureDeclaration.parameters.elements[i].element, 
-                           otherIndexSignatureDeclaration.parameters.elements[i].element);
-            if (!this.match) return indexSignatureDeclaration;
-        }
-
-        // Visit type expression
-        await this.visit(indexSignatureDeclaration.typeExpression.element, otherIndexSignatureDeclaration.typeExpression.element);
-
-        return indexSignatureDeclaration;
+        return this.visitElement(indexSignatureDeclaration, other as JS.IndexSignatureDeclaration);
     }
 
     /**
@@ -4340,22 +1668,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited for-of loop, or undefined if the visit was aborted
      */
     override async visitForOfLoop(forOfLoop: JS.ForOfLoop, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== JS.Kind.ForOfLoop) {
-            return this.abort(forOfLoop);
-        }
-
-        const otherForOfLoop = other as JS.ForOfLoop;
-
-        // Compare await
-        if ((forOfLoop.await === undefined) !== (otherForOfLoop.await === undefined)) {
-            return this.abort(forOfLoop);
-        }
-
-        // Visit loop
-        await this.visit(forOfLoop.loop, otherForOfLoop.loop);
-        if (!this.match) return forOfLoop;
-
-        return forOfLoop;
+        return this.visitElement(forOfLoop, other as JS.ForOfLoop);
     }
 
     /**
@@ -4366,69 +1679,18 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited for-in loop, or undefined if the visit was aborted
      */
     override async visitForInLoop(forInLoop: JS.ForInLoop, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== JS.Kind.ForInLoop) {
-            return this.abort(forInLoop);
-        }
-
-        const otherForInLoop = other as JS.ForInLoop;
-
-        // Visit control
-        await this.visit(forInLoop.control, otherForInLoop.control);
-        if (!this.match) return forInLoop;
-
-        // Visit body
-        await this.visit(forInLoop.body.element, otherForInLoop.body.element);
-        if (!this.match) return forInLoop;
-
-        return forInLoop;
+        return this.visitElement(forInLoop, other as JS.ForInLoop);
     }
 
     /**
-     * Overrides the visitNamespaceDeclaration method to compare namespace declarations.
-     * 
-     * @param namespaceDeclaration The namespace declaration to visit
-     * @param other The other namespace declaration to compare with
-     * @returns The visited namespace declaration, or undefined if the visit was aborted
-     */
-    override async visitNamespaceDeclaration(namespaceDeclaration: JS.NamespaceDeclaration, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== JS.Kind.NamespaceDeclaration) {
-            return this.abort(namespaceDeclaration);
-        }
-
-        const otherNamespaceDeclaration = other as JS.NamespaceDeclaration;
-
-        // Compare modifiers
-        if (namespaceDeclaration.modifiers.length !== otherNamespaceDeclaration.modifiers.length) {
-            return this.abort(namespaceDeclaration);
-        }
-
-        // Visit each modifier in lock step
-        for (let i = 0; i < namespaceDeclaration.modifiers.length; i++) {
-            await this.visit(namespaceDeclaration.modifiers[i], otherNamespaceDeclaration.modifiers[i]);
-            if (!this.match) return namespaceDeclaration;
-        }
-
-        // Compare keywordType
-        if (namespaceDeclaration.keywordType.element !== otherNamespaceDeclaration.keywordType.element) {
-            return this.abort(namespaceDeclaration);
-        }
-
-        // Visit name
-        await this.visit(namespaceDeclaration.name.element, otherNamespaceDeclaration.name.element);
-        if (!this.match) return namespaceDeclaration;
-
-        // Compare body
-        if ((namespaceDeclaration.body === undefined) !== (otherNamespaceDeclaration.body === undefined)) {
-            return this.abort(namespaceDeclaration);
-        }
-
-        // Visit body if present
-        if (namespaceDeclaration.body && otherNamespaceDeclaration.body) {
-            await this.visit(namespaceDeclaration.body, otherNamespaceDeclaration.body);
-            if (!this.match) return namespaceDeclaration;
-        }
-
-        return namespaceDeclaration;
+     * Overrides the visitNamespaceDeclaration method to compare namespace declarations.
+     * 
+     * @param namespaceDeclaration The namespace declaration to visit
+     * @param other The other namespace declaration to compare with
+     * @returns The visited namespace declaration, or undefined if the visit was aborted
+     */
+    override async visitNamespaceDeclaration(namespaceDeclaration: JS.NamespaceDeclaration, other: J): Promise<J | undefined> {
+        return this.visitElement(namespaceDeclaration, other as JS.NamespaceDeclaration);
     }
 
     /**
@@ -4439,17 +1701,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited type literal, or undefined if the visit was aborted
      */
     override async visitTypeLiteral(typeLiteral: JS.TypeLiteral, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== JS.Kind.TypeLiteral) {
-            return this.abort(typeLiteral);
-        }
-
-        const otherTypeLiteral = other as JS.TypeLiteral;
-
-        // Visit members
-        await this.visit(typeLiteral.members, otherTypeLiteral.members);
-        if (!this.match) return typeLiteral;
-
-        return typeLiteral;
+        return this.visitElement(typeLiteral, other as JS.TypeLiteral);
     }
 
     /**
@@ -4460,39 +1712,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited binding element, or undefined if the visit was aborted
      */
     override async visitBindingElement(bindingElement: JS.BindingElement, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== JS.Kind.BindingElement) {
-            return this.abort(bindingElement);
-        }
-
-        const otherBindingElement = other as JS.BindingElement;
-
-        // Compare propertyName
-        if ((bindingElement.propertyName === undefined) !== (otherBindingElement.propertyName === undefined)) {
-            return this.abort(bindingElement);
-        }
-
-        // Visit propertyName if present
-        if (bindingElement.propertyName && otherBindingElement.propertyName) {
-            await this.visit(bindingElement.propertyName.element, otherBindingElement.propertyName.element);
-            if (!this.match) return bindingElement;
-        }
-
-        // Visit name
-        await this.visit(bindingElement.name, otherBindingElement.name);
-        if (!this.match) return bindingElement;
-
-        // Compare initializer
-        if ((bindingElement.initializer === undefined) !== (otherBindingElement.initializer === undefined)) {
-            return this.abort(bindingElement);
-        }
-
-        // Visit initializer if present
-        if (bindingElement.initializer && otherBindingElement.initializer) {
-            await this.visit(bindingElement.initializer.element, otherBindingElement.initializer.element);
-            if (!this.match) return bindingElement;
-        }
-
-        return bindingElement;
+        return this.visitElement(bindingElement, other as JS.BindingElement);
     }
 
     /**
@@ -4503,24 +1723,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited array binding pattern, or undefined if the visit was aborted
      */
     override async visitArrayBindingPattern(arrayBindingPattern: JS.ArrayBindingPattern, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== JS.Kind.ArrayBindingPattern) {
-            return this.abort(arrayBindingPattern);
-        }
-
-        const otherArrayBindingPattern = other as JS.ArrayBindingPattern;
-
-        // Compare elements
-        if (arrayBindingPattern.elements.elements.length !== otherArrayBindingPattern.elements.elements.length) {
-            return this.abort(arrayBindingPattern);
-        }
-
-        // Visit each element in lock step
-        for (let i = 0; i < arrayBindingPattern.elements.elements.length; i++) {
-            await this.visit(arrayBindingPattern.elements.elements[i].element, otherArrayBindingPattern.elements.elements[i].element);
-            if (!this.match) return arrayBindingPattern;
-        }
-
-        return arrayBindingPattern;
+        return this.visitElement(arrayBindingPattern, other as JS.ArrayBindingPattern);
     }
 
     /**
@@ -4531,62 +1734,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited export declaration, or undefined if the visit was aborted
      */
     override async visitExportDeclaration(exportDeclaration: JS.ExportDeclaration, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== JS.Kind.ExportDeclaration) {
-            return this.abort(exportDeclaration);
-        }
-
-        const otherExportDeclaration = other as JS.ExportDeclaration;
-
-        // Compare modifiers
-        if (exportDeclaration.modifiers.length !== otherExportDeclaration.modifiers.length) {
-            return this.abort(exportDeclaration);
-        }
-
-        // Visit each modifier in lock step
-        for (let i = 0; i < exportDeclaration.modifiers.length; i++) {
-            await this.visit(exportDeclaration.modifiers[i], otherExportDeclaration.modifiers[i]);
-            if (!this.match) return exportDeclaration;
-        }
-
-        // Compare typeOnly
-        if (exportDeclaration.typeOnly.element !== otherExportDeclaration.typeOnly.element) {
-            return this.abort(exportDeclaration);
-        }
-
-        // Compare exportClause
-        if ((exportDeclaration.exportClause === undefined) !== (otherExportDeclaration.exportClause === undefined)) {
-            return this.abort(exportDeclaration);
-        }
-
-        // Visit exportClause if present
-        if (exportDeclaration.exportClause && otherExportDeclaration.exportClause) {
-            await this.visit(exportDeclaration.exportClause, otherExportDeclaration.exportClause);
-            if (!this.match) return exportDeclaration;
-        }
-
-        // Compare moduleSpecifier
-        if ((exportDeclaration.moduleSpecifier === undefined) !== (otherExportDeclaration.moduleSpecifier === undefined)) {
-            return this.abort(exportDeclaration);
-        }
-
-        // Visit moduleSpecifier if present
-        if (exportDeclaration.moduleSpecifier && otherExportDeclaration.moduleSpecifier) {
-            await this.visit(exportDeclaration.moduleSpecifier.element, otherExportDeclaration.moduleSpecifier.element);
-            if (!this.match) return exportDeclaration;
-        }
-
-        // Compare attributes
-        if ((exportDeclaration.attributes === undefined) !== (otherExportDeclaration.attributes === undefined)) {
-            return this.abort(exportDeclaration);
-        }
-
-        // Visit attributes if present
-        if (exportDeclaration.attributes && otherExportDeclaration.attributes) {
-            await this.visit(exportDeclaration.attributes, otherExportDeclaration.attributes);
-            if (!this.match) return exportDeclaration;
-        }
-
-        return exportDeclaration;
+        return this.visitElement(exportDeclaration, other as JS.ExportDeclaration);
     }
 
     /**
@@ -4597,22 +1745,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited export assignment, or undefined if the visit was aborted
      */
     override async visitExportAssignment(exportAssignment: JS.ExportAssignment, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== JS.Kind.ExportAssignment) {
-            return this.abort(exportAssignment);
-        }
-
-        const otherExportAssignment = other as JS.ExportAssignment;
-
-        // Compare exportEquals
-        if (exportAssignment.exportEquals !== otherExportAssignment.exportEquals) {
-            return this.abort(exportAssignment);
-        }
-
-        // Visit expression
-        await this.visit(exportAssignment.expression.element, otherExportAssignment.expression.element);
-        if (!this.match) return exportAssignment;
-
-        return exportAssignment;
+        return this.visitElement(exportAssignment, other as JS.ExportAssignment);
     }
 
     /**
@@ -4623,24 +1756,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited named exports, or undefined if the visit was aborted
      */
     override async visitNamedExports(namedExports: JS.NamedExports, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== JS.Kind.NamedExports) {
-            return this.abort(namedExports);
-        }
-
-        const otherNamedExports = other as JS.NamedExports;
-
-        // Compare elements
-        if (namedExports.elements.elements.length !== otherNamedExports.elements.elements.length) {
-            return this.abort(namedExports);
-        }
-
-        // Visit each element in lock step
-        for (let i = 0; i < namedExports.elements.elements.length; i++) {
-            await this.visit(namedExports.elements.elements[i].element, otherNamedExports.elements.elements[i].element);
-            if (!this.match) return namedExports;
-        }
-
-        return namedExports;
+        return this.visitElement(namedExports, other as JS.NamedExports);
     }
 
     /**
@@ -4651,22 +1767,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited export specifier, or undefined if the visit was aborted
      */
     override async visitExportSpecifier(exportSpecifier: JS.ExportSpecifier, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== JS.Kind.ExportSpecifier) {
-            return this.abort(exportSpecifier);
-        }
-
-        const otherExportSpecifier = other as JS.ExportSpecifier;
-
-        // Compare typeOnly
-        if (exportSpecifier.typeOnly.element !== otherExportSpecifier.typeOnly.element) {
-            return this.abort(exportSpecifier);
-        }
-
-        // Visit specifier
-        await this.visit(exportSpecifier.specifier, otherExportSpecifier.specifier);
-        if (!this.match) return exportSpecifier;
-
-        return exportSpecifier;
+        return this.visitElement(exportSpecifier, other as JS.ExportSpecifier);
     }
 
     /**
@@ -4677,80 +1778,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * @returns The visited computed property method declaration, or undefined if the visit was aborted
      */
     override async visitComputedPropertyMethodDeclaration(computedPropMethod: JS.ComputedPropertyMethodDeclaration, other: J): Promise<J | undefined> {
-        if (!this.match || other.kind !== JS.Kind.ComputedPropertyMethodDeclaration) {
-            return this.abort(computedPropMethod);
-        }
-
-        const otherComputedPropMethod = other as JS.ComputedPropertyMethodDeclaration;
-
-        // Compare leading annotations
-        if (computedPropMethod.leadingAnnotations.length !== otherComputedPropMethod.leadingAnnotations.length) {
-            return this.abort(computedPropMethod);
-        }
-
-        // Visit leading annotations in lock step
-        for (let i = 0; i < computedPropMethod.leadingAnnotations.length; i++) {
-            await this.visit(computedPropMethod.leadingAnnotations[i], otherComputedPropMethod.leadingAnnotations[i]);
-            if (!this.match) return computedPropMethod;
-        }
-
-        // Compare modifiers
-        if (computedPropMethod.modifiers.length !== otherComputedPropMethod.modifiers.length) {
-            return this.abort(computedPropMethod);
-        }
-
-        // Visit modifiers in lock step
-        for (let i = 0; i < computedPropMethod.modifiers.length; i++) {
-            await this.visit(computedPropMethod.modifiers[i], otherComputedPropMethod.modifiers[i]);
-            if (!this.match) return computedPropMethod;
-        }
-
-        // Compare type parameters
-        if (!!computedPropMethod.typeParameters !== !!otherComputedPropMethod.typeParameters) {
-            return this.abort(computedPropMethod);
-        }
-
-        if (computedPropMethod.typeParameters) {
-            await this.visit(computedPropMethod.typeParameters, otherComputedPropMethod.typeParameters!);
-            if (!this.match) return computedPropMethod;
-        }
-
-        // Compare return type expression
-        if (!!computedPropMethod.returnTypeExpression !== !!otherComputedPropMethod.returnTypeExpression) {
-            return this.abort(computedPropMethod);
-        }
-
-        if (computedPropMethod.returnTypeExpression) {
-            await this.visit(computedPropMethod.returnTypeExpression, otherComputedPropMethod.returnTypeExpression!);
-            if (!this.match) return computedPropMethod;
-        }
-
-        // Visit name
-        await this.visit(computedPropMethod.name, otherComputedPropMethod.name);
-        if (!this.match) return computedPropMethod;
-
-        // Compare parameters
-        if (computedPropMethod.parameters.elements.length !== otherComputedPropMethod.parameters.elements.length) {
-            return this.abort(computedPropMethod);
-        }
-
-        // Visit parameters in lock step
-        for (let i = 0; i < computedPropMethod.parameters.elements.length; i++) {
-            await this.visit(computedPropMethod.parameters.elements[i].element, 
-                           otherComputedPropMethod.parameters.elements[i].element);
-            if (!this.match) return computedPropMethod;
-        }
-
-        // Compare body
-        if (!!computedPropMethod.body !== !!otherComputedPropMethod.body) {
-            return this.abort(computedPropMethod);
-        }
-
-        if (computedPropMethod.body) {
-            await this.visit(computedPropMethod.body, otherComputedPropMethod.body!);
-        }
-
-        return computedPropMethod;
+        return this.visitElement(computedPropMethod, other as JS.ComputedPropertyMethodDeclaration);
     }
 }
 
@@ -4761,13 +1789,58 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
  * when both refer to the same method).
  */
 export class JavaScriptSemanticComparatorVisitor extends JavaScriptComparatorVisitor {
+    /**
+     * When true, allows patterns without type annotations to match code with type annotations.
+     * This enables lenient matching where undefined types on either side are considered compatible.
+     */
+    protected readonly lenientTypeMatching: boolean;
+
+    /**
+     * Creates a new semantic comparator visitor.
+     *
+     * @param lenientTypeMatching If true, allows matching between nodes with and without type annotations
+     */
+    constructor(lenientTypeMatching: boolean = false) {
+        super();
+        this.lenientTypeMatching = lenientTypeMatching;
+    }
+
+    /**
+     * 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).
+     */
+    protected override async visitProperty(j: any, other: any): Promise<any> {
+        // Handle null/undefined with lenient type matching
+        if (this.lenientTypeMatching && (j == null || other == null)) {
+            if (j !== other) {
+                // Don't abort if one is null and the other is a Type
+                const jKind = (j as any)?.kind;
+                const otherKind = (other as any)?.kind;
+                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);
+                }
+            }
+            return j;
+        }
+
+        // Otherwise, use base class behavior
+        return super.visitProperty(j, other);
+    }
+
     /**
      * Checks if two types are semantically equal.
      * For method types, this checks that the declaring type and method name match.
+     * With lenient type matching, undefined types on either side are considered compatible.
      */
     private isOfType(target?: Type, source?: Type): boolean {
         if (!target || !source) {
-            return target === source;
+            // Lenient mode: if either type is undefined, allow the match
+            return this.lenientTypeMatching ? true : target === source;
         }
 
         if (target.kind !== source.kind) {
@@ -4858,7 +1931,11 @@ export class JavaScriptSemanticComparatorVisitor extends JavaScriptComparatorVis
         // Check type attribution
         // Both must have method types for semantic equality
         if (!method.methodType || !otherMethod.methodType) {
-            // If template has type but target doesn't, they don't match
+            // Lenient mode: if either has no type, allow structural matching
+            if (this.lenientTypeMatching) {
+                return super.visitMethodInvocation(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);
             }
@@ -4891,9 +1968,6 @@ export class JavaScriptSemanticComparatorVisitor extends JavaScriptComparatorVis
 
             if (method.select && otherMethod.select) {
                 await this.visit(method.select.element, otherMethod.select.element);
-                if (!this.match) {
-                    return this.abort(method);
-                }
             }
         }
 
@@ -4952,10 +2026,167 @@ export class JavaScriptSemanticComparatorVisitor extends JavaScriptComparatorVis
                 return this.abort(identifier);
             }
         } else if (identifier.fieldType || otherIdentifier.fieldType) {
-            // If only one has a type, they don't match
-            return this.abort(identifier);
+            // 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 super.visitIdentifier(identifier, other);
     }
+
+    /**
+     * Override variable declarations comparison to handle lenient type matching.
+     * When lenientTypeMatching is true, patterns without typeExpression can match
+     * code with typeExpression.
+     */
+    override async visitVariableDeclarations(variableDeclarations: J.VariableDeclarations, other: J): Promise<J | undefined> {
+        const otherVariableDeclarations = other as J.VariableDeclarations;
+
+        // Visit leading annotations
+        if (variableDeclarations.leadingAnnotations.length !== otherVariableDeclarations.leadingAnnotations.length) {
+            return this.abort(variableDeclarations);
+        }
+
+        for (let i = 0; i < variableDeclarations.leadingAnnotations.length; i++) {
+            await this.visit(variableDeclarations.leadingAnnotations[i], otherVariableDeclarations.leadingAnnotations[i]);
+            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++) {
+            await this.visit(variableDeclarations.modifiers[i], otherVariableDeclarations.modifiers[i]);
+            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);
+            }
+            // In lenient mode, skip type comparison and continue
+        } else if (variableDeclarations.typeExpression && otherVariableDeclarations.typeExpression) {
+            // Both have typeExpression, visit them
+            await this.visit(variableDeclarations.typeExpression, otherVariableDeclarations.typeExpression);
+            if (!this.match) return variableDeclarations;
+        }
+
+        // Compare varargs
+        if ((variableDeclarations.varargs === undefined) !== (otherVariableDeclarations.varargs === undefined)) {
+            return this.abort(variableDeclarations);
+        }
+
+        // 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++) {
+            await this.visit(variableDeclarations.variables[i].element, otherVariableDeclarations.variables[i].element);
+            if (!this.match) return variableDeclarations;
+        }
+
+        return variableDeclarations;
+    }
+
+    /**
+     * Override method declaration comparison to handle lenient type matching.
+     * When lenientTypeMatching is true, patterns without returnTypeExpression can match
+     * code with returnTypeExpression.
+     */
+    override async visitMethodDeclaration(methodDeclaration: J.MethodDeclaration, other: J): Promise<J | undefined> {
+        const otherMethodDeclaration = other as J.MethodDeclaration;
+
+        // Visit leading annotations
+        if (methodDeclaration.leadingAnnotations.length !== otherMethodDeclaration.leadingAnnotations.length) {
+            return this.abort(methodDeclaration);
+        }
+
+        for (let i = 0; i < methodDeclaration.leadingAnnotations.length; i++) {
+            await this.visit(methodDeclaration.leadingAnnotations[i], otherMethodDeclaration.leadingAnnotations[i]);
+            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++) {
+            await this.visit(methodDeclaration.modifiers[i], otherMethodDeclaration.modifiers[i]);
+            if (!this.match) return methodDeclaration;
+        }
+
+        // Visit type parameters if present
+        if (!!methodDeclaration.typeParameters !== !!otherMethodDeclaration.typeParameters) {
+            return this.abort(methodDeclaration);
+        }
+
+        if (methodDeclaration.typeParameters && otherMethodDeclaration.typeParameters) {
+            await this.visit(methodDeclaration.typeParameters, otherMethodDeclaration.typeParameters);
+            if (!this.match) return methodDeclaration;
+        }
+
+        // Compare returnTypeExpression - lenient matching allows one to be undefined
+        if ((methodDeclaration.returnTypeExpression === undefined) !== (otherMethodDeclaration.returnTypeExpression === undefined)) {
+            if (!this.lenientTypeMatching) {
+                return this.abort(methodDeclaration);
+            }
+            // In lenient mode, skip type comparison and continue
+        } else if (methodDeclaration.returnTypeExpression && otherMethodDeclaration.returnTypeExpression) {
+            // Both have returnTypeExpression, visit them
+            await this.visit(methodDeclaration.returnTypeExpression, otherMethodDeclaration.returnTypeExpression);
+            if (!this.match) return methodDeclaration;
+        }
+
+        // Visit name
+        await this.visit(methodDeclaration.name, otherMethodDeclaration.name);
+        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++) {
+            await this.visit(methodDeclaration.parameters.elements[i].element, otherMethodDeclaration.parameters.elements[i].element);
+            if (!this.match) return methodDeclaration;
+        }
+
+        // Visit throws if present
+        if (!!methodDeclaration.throws !== !!otherMethodDeclaration.throws) {
+            return this.abort(methodDeclaration);
+        }
+
+        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++) {
+                await this.visit(methodDeclaration.throws.elements[i].element, otherMethodDeclaration.throws.elements[i].element);
+                if (!this.match) return methodDeclaration;
+            }
+        }
+
+        // Visit body if present
+        if (!!methodDeclaration.body !== !!otherMethodDeclaration.body) {
+            return this.abort(methodDeclaration);
+        }
+
+        if (methodDeclaration.body && otherMethodDeclaration.body) {
+            await this.visit(methodDeclaration.body, otherMethodDeclaration.body);
+            if (!this.match) return methodDeclaration;
+        }
+
+        return methodDeclaration;
+    }
 }