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

package/dist/javascript/comparator.js

@@ -27,18 +27,15 @@ exports.JavaScriptSemanticComparatorVisitor = exports.JavaScriptComparatorVisito
  */
 const visitor_1 = require("./visitor");
 const java_1 = require("../java");
-const tree_1 = require("./tree");
+const tree_1 = require("../tree");
 /**
  * A visitor that compares two AST trees in lock step.
  * It takes another `J` instance as context and visits both trees simultaneously.
  * The visit operation is aborted when the nodes don't match.
  */
 class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
-    /**
-     * Creates a new comparator visitor.
-     */
     constructor() {
-        super();
+        super(...arguments);
         /**
          * Flag indicating whether the trees match so far
          */
@@ -75,6 +72,102 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
         this.match = false;
         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
+     */
+    visitProperty(j, other) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Handle null/undefined (but not other falsy values like 0, false, '')
+            if (j == null || other == null) {
+                if (j !== other) {
+                    this.abort(j);
+                }
+                return j;
+            }
+            const kind = j.kind;
+            // Check wrappers by kind
+            if (kind === java_1.J.Kind.RightPadded) {
+                return yield this.visitRightPadded(j, other);
+            }
+            if (kind === java_1.J.Kind.LeftPadded) {
+                return yield this.visitLeftPadded(j, other);
+            }
+            if (kind === java_1.J.Kind.Container) {
+                return yield this.visitContainer(j, other);
+            }
+            // Check if it's a Space (skip comparison)
+            if (kind === java_1.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 yield this.visitType(j, other);
+                }
+                return yield 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
+     */
+    visitElement(j, other) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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[key];
+                const otherValue = other[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++) {
+                        yield this.visitProperty(jValue[i], otherValue[i]);
+                        if (!this.match) {
+                            return j;
+                        }
+                    }
+                }
+                else {
+                    // Visit the property (which will handle wrappers, trees, primitives, etc.)
+                    yield this.visitProperty(jValue, otherValue);
+                    if (!this.match) {
+                        return j;
+                    }
+                }
+            }
+            return j;
+        });
+    }
     visit(j, p, parent) {
         const _super = Object.create(null, {
             visit: { get: () => super.visit }
@@ -92,6 +185,93 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
             return _super.visit.call(this, j, p);
         });
     }
+    /**
+     * Override visitRightPadded to compare only the elements, not markers or spacing.
+     * The context parameter p contains the corresponding element from the other tree.
+     * Pushes the wrapper onto the cursor stack so captures can access it.
+     */
+    visitRightPadded(right, p) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.match) {
+                return right;
+            }
+            // Extract the other element if it's also a RightPadded
+            const otherElement = p.kind === java_1.J.Kind.RightPadded
+                ? p.element
+                : p;
+            // Push wrapper onto cursor, then compare only the elements, not markers or spacing
+            const savedCursor = this.cursor;
+            this.cursor = new tree_1.Cursor(right, this.cursor);
+            try {
+                yield 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.
+     */
+    visitLeftPadded(left, p) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.match) {
+                return left;
+            }
+            // Extract the other element if it's also a LeftPadded
+            const otherElement = p.kind === java_1.J.Kind.LeftPadded
+                ? p.element
+                : p;
+            // Push wrapper onto cursor, then compare only the elements, not markers or spacing
+            const savedCursor = this.cursor;
+            this.cursor = new tree_1.Cursor(left, this.cursor);
+            try {
+                yield 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.
+     */
+    visitContainer(container, p) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.match) {
+                return container;
+            }
+            // Extract the other elements if it's also a Container
+            const otherElements = p.kind === java_1.J.Kind.Container
+                ? p.elements
+                : p;
+            // 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 tree_1.Cursor(container, this.cursor);
+            try {
+                for (let i = 0; i < container.elements.length; i++) {
+                    yield this.visitProperty(container.elements[i], otherElements[i]);
+                    if (!this.match) {
+                        return this.abort(container);
+                    }
+                }
+            }
+            finally {
+                this.cursor = savedCursor;
+            }
+            return container;
+        });
+    }
     /**
      * Overrides the visitBinary method to compare binary expressions.
      *
@@ -101,19 +281,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitBinary(binary, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== java_1.J.Kind.Binary) {
-                return this.abort(binary);
-            }
-            const otherBinary = other;
-            if (binary.operator.element !== otherBinary.operator.element) {
-                return this.abort(binary);
-            }
-            // Visit left and right operands in lock step
-            yield this.visit(binary.left, otherBinary.left);
-            if (!this.match)
-                return this.abort(binary);
-            yield this.visit(binary.right, otherBinary.right);
-            return binary;
+            return this.visitElement(binary, other);
         });
     }
     /**
@@ -125,14 +293,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitIdentifier(identifier, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== java_1.J.Kind.Identifier) {
-                return this.abort(identifier);
-            }
-            const otherIdentifier = other;
-            if (identifier.simpleName !== otherIdentifier.simpleName) {
-                return this.abort(identifier);
-            }
-            return identifier;
+            return this.visitElement(identifier, other);
         });
     }
     /**
@@ -144,14 +305,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitLiteral(literal, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== java_1.J.Kind.Literal) {
-                return this.abort(literal);
-            }
-            const otherLiteral = other;
-            if (literal.valueSource !== otherLiteral.valueSource) {
-                return this.abort(literal);
-            }
-            return literal;
+            return this.visitElement(literal, other);
         });
     }
     /**
@@ -163,21 +317,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitBlock(block, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== java_1.J.Kind.Block) {
-                return this.abort(block);
-            }
-            const otherBlock = other;
-            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++) {
-                yield this.visit(block.statements[i].element, otherBlock.statements[i].element);
-                if (!this.match) {
-                    return this.abort(block);
-                }
-            }
-            return block;
+            return this.visitElement(block, other);
         });
     }
     /**
@@ -189,21 +329,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitJsCompilationUnit(compilationUnit, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== tree_1.JS.Kind.CompilationUnit) {
-                return this.abort(compilationUnit);
-            }
-            const otherCompilationUnit = other;
-            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++) {
-                yield this.visit(compilationUnit.statements[i].element, otherCompilationUnit.statements[i].element);
-                if (!this.match) {
-                    return this.abort(compilationUnit);
-                }
-            }
-            return compilationUnit;
+            return this.visitElement(compilationUnit, other);
         });
     }
     /**
@@ -215,17 +341,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitAlias(alias, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== tree_1.JS.Kind.Alias) {
-                return this.abort(alias);
-            }
-            const otherAlias = other;
-            // Visit property name and alias in lock step
-            yield this.visit(alias.propertyName.element, otherAlias.propertyName.element);
-            if (!this.match) {
-                return this.abort(alias);
-            }
-            yield this.visit(alias.alias, otherAlias.alias);
-            return alias;
+            return this.visitElement(alias, other);
         });
     }
     /**
@@ -237,41 +353,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitArrowFunction(arrowFunction, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== tree_1.JS.Kind.ArrowFunction) {
-                return this.abort(arrowFunction);
-            }
-            const otherArrowFunction = other;
-            // 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++) {
-                yield 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) {
-                yield this.visit(arrowFunction.typeParameters, otherArrowFunction.typeParameters);
-                if (!this.match)
-                    return arrowFunction;
-            }
-            // Visit lambda
-            yield 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) {
-                yield this.visit(arrowFunction.returnTypeExpression, otherArrowFunction.returnTypeExpression);
-            }
-            return arrowFunction;
+            return this.visitElement(arrowFunction, other);
         });
     }
     /**
@@ -283,13 +365,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitAwait(await_, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== tree_1.JS.Kind.Await) {
-                return this.abort(await_);
-            }
-            const otherAwait = other;
-            // Visit expression
-            yield this.visit(await_.expression, otherAwait.expression);
-            return await_;
+            return this.visitElement(await_, other);
         });
     }
     /**
@@ -301,51 +377,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitJsxTag(element, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== tree_1.JS.Kind.JsxTag) {
-                return this.abort(element);
-            }
-            const otherElement = other;
-            // Visit open name
-            yield 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++) {
-                yield 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++) {
-                    yield 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) {
-                yield this.visit(element.closingName.element, otherElement.closingName.element);
-            }
-            return element;
+            return this.visitElement(element, other);
         });
     }
     /**
@@ -357,22 +389,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitJsxAttribute(attribute, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== tree_1.JS.Kind.JsxAttribute) {
-                return this.abort(attribute);
-            }
-            const otherAttribute = other;
-            // Visit key
-            yield 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) {
-                yield this.visit(attribute.value.element, otherAttribute.value.element);
-            }
-            return attribute;
+            return this.visitElement(attribute, other);
         });
     }
     /**
@@ -384,13 +401,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitJsxSpreadAttribute(spread, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== tree_1.JS.Kind.JsxSpreadAttribute) {
-                return this.abort(spread);
-            }
-            const otherSpread = other;
-            // Visit expression
-            yield this.visit(spread.expression.element, otherSpread.expression.element);
-            return spread;
+            return this.visitElement(spread, other);
         });
     }
     /**
@@ -402,13 +413,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitJsxEmbeddedExpression(expr, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== tree_1.JS.Kind.JsxEmbeddedExpression) {
-                return this.abort(expr);
-            }
-            const otherExpr = other;
-            // Visit expression
-            yield this.visit(expr.expression.element, otherExpr.expression.element);
-            return expr;
+            return this.visitElement(expr, other);
         });
     }
     /**
@@ -420,17 +425,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitJsxNamespacedName(ns, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== tree_1.JS.Kind.JsxNamespacedName) {
-                return this.abort(ns);
-            }
-            const otherNs = other;
-            // Visit namespace
-            yield this.visit(ns.namespace, otherNs.namespace);
-            if (!this.match)
-                return ns;
-            // Visit name
-            yield this.visit(ns.name.element, otherNs.name.element);
-            return ns;
+            return this.visitElement(ns, other);
         });
     }
     /**
@@ -442,17 +437,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitConditionalType(conditionalType, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== tree_1.JS.Kind.ConditionalType) {
-                return this.abort(conditionalType);
-            }
-            const otherConditionalType = other;
-            // Visit check type
-            yield this.visit(conditionalType.checkType, otherConditionalType.checkType);
-            if (!this.match)
-                return conditionalType;
-            // Visit condition
-            yield this.visit(conditionalType.condition.element, otherConditionalType.condition.element);
-            return conditionalType;
+            return this.visitElement(conditionalType, other);
         });
     }
     /**
@@ -464,13 +449,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitDelete(delete_, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== tree_1.JS.Kind.Delete) {
-                return this.abort(delete_);
-            }
-            const otherDelete = other;
-            // Visit expression
-            yield this.visit(delete_.expression, otherDelete.expression);
-            return delete_;
+            return this.visitElement(delete_, other);
         });
     }
     /**
@@ -482,13 +461,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitExpressionStatement(expressionStatement, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== tree_1.JS.Kind.ExpressionStatement) {
-                return this.abort(expressionStatement);
-            }
-            const otherExpressionStatement = other;
-            // Visit expression
-            yield this.visit(expressionStatement.expression, otherExpressionStatement.expression);
-            return expressionStatement;
+            return this.visitElement(expressionStatement, other);
         });
     }
     /**
@@ -500,30 +473,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitExpressionWithTypeArguments(expressionWithTypeArguments, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== tree_1.JS.Kind.ExpressionWithTypeArguments) {
-                return this.abort(expressionWithTypeArguments);
-            }
-            const otherExpressionWithTypeArguments = other;
-            // Visit class
-            yield 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++) {
-                    yield this.visit(expressionWithTypeArguments.typeArguments.elements[i].element, otherExpressionWithTypeArguments.typeArguments.elements[i].element);
-                    if (!this.match)
-                        return expressionWithTypeArguments;
-                }
-            }
-            return expressionWithTypeArguments;
+            return this.visitElement(expressionWithTypeArguments, other);
         });
     }
     /**
@@ -535,47 +485,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitFunctionCall(functionCall, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== tree_1.JS.Kind.FunctionCall) {
-                return this.abort(functionCall);
-            }
-            const otherFunctionCall = other;
-            // Compare function
-            if ((functionCall.function === undefined) !== (otherFunctionCall.function === undefined)) {
-                return this.abort(functionCall);
-            }
-            // Visit function if present
-            if (functionCall.function && otherFunctionCall.function) {
-                yield 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++) {
-                    yield 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++) {
-                yield this.visit(functionCall.arguments.elements[i].element, otherFunctionCall.arguments.elements[i].element);
-                if (!this.match)
-                    return functionCall;
-            }
-            return functionCall;
+            return this.visitElement(functionCall, other);
         });
     }
     /**
@@ -587,41 +497,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitFunctionType(functionType, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== tree_1.JS.Kind.FunctionType) {
-                return this.abort(functionType);
-            }
-            const otherFunctionType = other;
-            // 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) {
-                yield 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++) {
-                yield this.visit(functionType.parameters.elements[i].element, otherFunctionType.parameters.elements[i].element);
-                if (!this.match)
-                    return functionType;
-            }
-            // Compare return type
-            yield this.visit(functionType.returnType.element, otherFunctionType.returnType.element);
-            return functionType;
+            return this.visitElement(functionType, other);
         });
     }
     /**
@@ -633,13 +509,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitInferType(inferType, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== tree_1.JS.Kind.InferType) {
-                return this.abort(inferType);
-            }
-            const otherInferType = other;
-            // Visit type parameter
-            yield this.visit(inferType.typeParameter.element, otherInferType.typeParameter.element);
-            return inferType;
+            return this.visitElement(inferType, other);
         });
     }
     /**
@@ -651,49 +521,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitImportType(importType, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== tree_1.JS.Kind.ImportType) {
-                return this.abort(importType);
-            }
-            const otherImportType = other;
-            // 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++) {
-                yield 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) {
-                yield 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++) {
-                    yield this.visit(importType.typeArguments.elements[i].element, otherImportType.typeArguments.elements[i].element);
-                    if (!this.match)
-                        return importType;
-                }
-            }
-            return importType;
+            return this.visitElement(importType, other);
         });
     }
     /**
@@ -705,49 +533,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitImportDeclaration(jsImport, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== tree_1.JS.Kind.Import) {
-                return this.abort(jsImport);
-            }
-            const otherImport = other;
-            // 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++) {
-                yield 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) {
-                yield this.visit(jsImport.importClause, otherImport.importClause);
-                if (!this.match)
-                    return jsImport;
-            }
-            // Visit module specifier
-            if (jsImport.moduleSpecifier) {
-                yield 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) {
-                yield this.visit(jsImport.attributes, otherImport.attributes);
-            }
-            // Compare initializer
-            if (jsImport.initializer) {
-                yield this.visit(jsImport.initializer.element, otherImport.initializer.element);
-                if (!this.match)
-                    return jsImport;
-            }
-            return jsImport;
+            return this.visitElement(jsImport, other);
         });
     }
     /**
@@ -759,27 +545,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitImportClause(importClause, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== tree_1.JS.Kind.ImportClause) {
-                return this.abort(importClause);
-            }
-            const otherImportClause = other;
-            // Compare name
-            if (!!importClause.name !== !!otherImportClause.name) {
-                return this.abort(importClause);
-            }
-            if (importClause.name) {
-                yield 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) {
-                yield this.visit(importClause.namedBindings, otherImportClause.namedBindings);
-            }
-            return importClause;
+            return this.visitElement(importClause, other);
         });
     }
     /**
@@ -791,21 +557,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitNamedImports(namedImports, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== tree_1.JS.Kind.NamedImports) {
-                return this.abort(namedImports);
-            }
-            const otherNamedImports = other;
-            // 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++) {
-                yield this.visit(namedImports.elements.elements[i].element, otherNamedImports.elements.elements[i].element);
-                if (!this.match)
-                    return namedImports;
-            }
-            return namedImports;
+            return this.visitElement(namedImports, other);
         });
     }
     /**
@@ -817,22 +569,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitImportSpecifier(importSpecifier, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== tree_1.JS.Kind.ImportSpecifier) {
-                return this.abort(importSpecifier);
-            }
-            const otherImportSpecifier = other;
-            // 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
-            yield this.visit(importSpecifier.specifier, otherImportSpecifier.specifier);
-            return importSpecifier;
+            return this.visitElement(importSpecifier, other);
         });
     }
     /**
@@ -844,21 +581,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitImportAttributes(importAttributes, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== tree_1.JS.Kind.ImportAttributes) {
-                return this.abort(importAttributes);
-            }
-            const otherImportAttributes = other;
-            // 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++) {
-                yield this.visit(importAttributes.elements.elements[i].element, otherImportAttributes.elements.elements[i].element);
-                if (!this.match)
-                    return importAttributes;
-            }
-            return importAttributes;
+            return this.visitElement(importAttributes, other);
         });
     }
     /**
@@ -870,25 +593,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitImportTypeAttributes(importTypeAttributes, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== tree_1.JS.Kind.ImportTypeAttributes) {
-                return this.abort(importTypeAttributes);
-            }
-            const otherImportTypeAttributes = other;
-            // Compare token
-            yield 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++) {
-                yield this.visit(importTypeAttributes.elements.elements[i].element, otherImportTypeAttributes.elements.elements[i].element);
-                if (!this.match)
-                    return importTypeAttributes;
-            }
-            return importTypeAttributes;
+            return this.visitElement(importTypeAttributes, other);
         });
     }
     /**
@@ -900,17 +605,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitImportAttribute(importAttribute, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== tree_1.JS.Kind.ImportAttribute) {
-                return this.abort(importAttribute);
-            }
-            const otherImportAttribute = other;
-            // Visit name
-            yield this.visit(importAttribute.name, otherImportAttribute.name);
-            if (!this.match)
-                return importAttribute;
-            // Visit value
-            yield this.visit(importAttribute.value.element, otherImportAttribute.value.element);
-            return importAttribute;
+            return this.visitElement(importAttribute, other);
         });
     }
     /**
@@ -922,21 +617,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitBinaryExtensions(jsBinary, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== tree_1.JS.Kind.Binary) {
-                return this.abort(jsBinary);
-            }
-            const otherBinary = other;
-            // Visit left operand
-            yield 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
-            yield this.visit(jsBinary.right, otherBinary.right);
-            return jsBinary;
+            return this.visitElement(jsBinary, other);
         });
     }
     /**
@@ -948,13 +629,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitLiteralType(literalType, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== tree_1.JS.Kind.LiteralType) {
-                return this.abort(literalType);
-            }
-            const otherLiteralType = other;
-            // Visit literal
-            yield this.visit(literalType.literal, otherLiteralType.literal);
-            return literalType;
+            return this.visitElement(literalType, other);
         });
     }
     /**
@@ -966,51 +641,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitMappedType(mappedType, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== tree_1.JS.Kind.MappedType) {
-                return this.abort(mappedType);
-            }
-            const otherMappedType = other;
-            // Compare prefix token
-            if (!!mappedType.prefixToken !== !!otherMappedType.prefixToken) {
-                return this.abort(mappedType);
-            }
-            if (mappedType.prefixToken) {
-                yield 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
-            yield 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) {
-                yield 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++) {
-                yield this.visit(mappedType.valueType.elements[i].element, otherMappedType.valueType.elements[i].element);
-                if (!this.match)
-                    return mappedType;
-            }
-            return mappedType;
+            return this.visitElement(mappedType, other);
         });
     }
     /**
@@ -1022,22 +653,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitMappedTypeKeysRemapping(keysRemapping, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== tree_1.JS.Kind.MappedTypeKeysRemapping) {
-                return this.abort(keysRemapping);
-            }
-            const otherKeysRemapping = other;
-            // Visit type parameter
-            yield 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) {
-                yield this.visit(keysRemapping.nameType.element, otherKeysRemapping.nameType.element);
-            }
-            return keysRemapping;
+            return this.visitElement(keysRemapping, other);
         });
     }
     /**
@@ -1049,17 +665,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitMappedTypeParameter(mappedTypeParameter, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== tree_1.JS.Kind.MappedTypeParameter) {
-                return this.abort(mappedTypeParameter);
-            }
-            const otherMappedTypeParameter = other;
-            // Visit name
-            yield this.visit(mappedTypeParameter.name, otherMappedTypeParameter.name);
-            if (!this.match)
-                return mappedTypeParameter;
-            // Visit iterate type
-            yield this.visit(mappedTypeParameter.iterateType.element, otherMappedTypeParameter.iterateType.element);
-            return mappedTypeParameter;
+            return this.visitElement(mappedTypeParameter, other);
         });
     }
     /**
@@ -1071,57 +677,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitObjectBindingPattern(objectBindingPattern, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== tree_1.JS.Kind.ObjectBindingPattern) {
-                return this.abort(objectBindingPattern);
-            }
-            const otherObjectBindingPattern = other;
-            // 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++) {
-                yield 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++) {
-                yield 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) {
-                yield 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++) {
-                yield 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) {
-                yield this.visit(objectBindingPattern.initializer.element, otherObjectBindingPattern.initializer.element);
-            }
-            return objectBindingPattern;
+            return this.visitElement(objectBindingPattern, other);
         });
     }
     /**
@@ -1133,22 +689,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitPropertyAssignment(propertyAssignment, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== tree_1.JS.Kind.PropertyAssignment) {
-                return this.abort(propertyAssignment);
-            }
-            const otherPropertyAssignment = other;
-            // Visit name
-            yield 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) {
-                yield this.visit(propertyAssignment.initializer, otherPropertyAssignment.initializer);
-            }
-            return propertyAssignment;
+            return this.visitElement(propertyAssignment, other);
         });
     }
     /**
@@ -1160,17 +701,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitSatisfiesExpression(satisfiesExpression, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== tree_1.JS.Kind.SatisfiesExpression) {
-                return this.abort(satisfiesExpression);
-            }
-            const otherSatisfiesExpression = other;
-            // Visit expression
-            yield this.visit(satisfiesExpression.expression, otherSatisfiesExpression.expression);
-            if (!this.match)
-                return satisfiesExpression;
-            // Visit satisfies type
-            yield this.visit(satisfiesExpression.satisfiesType.element, otherSatisfiesExpression.satisfiesType.element);
-            return satisfiesExpression;
+            return this.visitElement(satisfiesExpression, other);
         });
     }
     /**
@@ -1182,31 +713,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitScopedVariableDeclarations(scopedVariableDeclarations, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== tree_1.JS.Kind.ScopedVariableDeclarations) {
-                return this.abort(scopedVariableDeclarations);
-            }
-            const otherScopedVariableDeclarations = other;
-            // 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++) {
-                yield 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++) {
-                yield this.visit(scopedVariableDeclarations.variables[i].element, otherScopedVariableDeclarations.variables[i].element);
-                if (!this.match)
-                    return scopedVariableDeclarations;
-            }
-            return scopedVariableDeclarations;
+            return this.visitElement(scopedVariableDeclarations, other);
         });
     }
     /**
@@ -1218,13 +725,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitStatementExpression(statementExpression, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== tree_1.JS.Kind.StatementExpression) {
-                return this.abort(statementExpression);
-            }
-            const otherStatementExpression = other;
-            // Visit statement
-            yield this.visit(statementExpression.statement, otherStatementExpression.statement);
-            return statementExpression;
+            return this.visitElement(statementExpression, other);
         });
     }
     /**
@@ -1236,37 +737,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitTaggedTemplateExpression(taggedTemplateExpression, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== tree_1.JS.Kind.TaggedTemplateExpression) {
-                return this.abort(taggedTemplateExpression);
-            }
-            const otherTaggedTemplateExpression = other;
-            // Compare tag
-            if (!!taggedTemplateExpression.tag !== !!otherTaggedTemplateExpression.tag) {
-                return this.abort(taggedTemplateExpression);
-            }
-            if (taggedTemplateExpression.tag) {
-                yield 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++) {
-                    yield this.visit(taggedTemplateExpression.typeArguments.elements[i].element, otherTaggedTemplateExpression.typeArguments.elements[i].element);
-                    if (!this.match)
-                        return taggedTemplateExpression;
-                }
-            }
-            // Visit template expression
-            yield this.visit(taggedTemplateExpression.templateExpression, otherTaggedTemplateExpression.templateExpression);
-            return taggedTemplateExpression;
+            return this.visitElement(taggedTemplateExpression, other);
         });
     }
     /**
@@ -1278,25 +749,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitTemplateExpression(templateExpression, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== tree_1.JS.Kind.TemplateExpression) {
-                return this.abort(templateExpression);
-            }
-            const otherTemplateExpression = other;
-            // Visit head
-            yield 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++) {
-                yield this.visit(templateExpression.spans[i].element, otherTemplateExpression.spans[i].element);
-                if (!this.match)
-                    return templateExpression;
-            }
-            return templateExpression;
+            return this.visitElement(templateExpression, other);
         });
     }
     /**
@@ -1308,17 +761,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitTemplateExpressionSpan(span, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== tree_1.JS.Kind.TemplateExpressionSpan) {
-                return this.abort(span);
-            }
-            const otherSpan = other;
-            // Visit expression
-            yield this.visit(span.expression, otherSpan.expression);
-            if (!this.match)
-                return span;
-            // Visit tail
-            yield this.visit(span.tail, otherSpan.tail);
-            return span;
+            return this.visitElement(span, other);
         });
     }
     /**
@@ -1330,21 +773,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitTuple(tuple, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== tree_1.JS.Kind.Tuple) {
-                return this.abort(tuple);
-            }
-            const otherTuple = other;
-            // 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++) {
-                yield this.visit(tuple.elements.elements[i].element, otherTuple.elements.elements[i].element);
-                if (!this.match)
-                    return tuple;
-            }
-            return tuple;
+            return this.visitElement(tuple, other);
         });
     }
     /**
@@ -1356,36 +785,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitTypeDeclaration(typeDeclaration, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== tree_1.JS.Kind.TypeDeclaration) {
-                return this.abort(typeDeclaration);
-            }
-            const otherTypeDeclaration = other;
-            // 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++) {
-                yield this.visit(typeDeclaration.modifiers[i], otherTypeDeclaration.modifiers[i]);
-                if (!this.match)
-                    return typeDeclaration;
-            }
-            // Visit name
-            yield 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) {
-                yield this.visit(typeDeclaration.typeParameters, otherTypeDeclaration.typeParameters);
-                if (!this.match)
-                    return typeDeclaration;
-            }
-            // Visit initializer
-            yield this.visit(typeDeclaration.initializer.element, otherTypeDeclaration.initializer.element);
-            return typeDeclaration;
+            return this.visitElement(typeDeclaration, other);
         });
     }
     /**
@@ -1397,13 +797,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitTypeOf(typeOf, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== tree_1.JS.Kind.TypeOf) {
-                return this.abort(typeOf);
-            }
-            const otherTypeOf = other;
-            // Visit expression
-            yield this.visit(typeOf.expression, otherTypeOf.expression);
-            return typeOf;
+            return this.visitElement(typeOf, other);
         });
     }
     /**
@@ -1415,13 +809,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitTypeTreeExpression(typeTreeExpression, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== tree_1.JS.Kind.TypeTreeExpression) {
-                return this.abort(typeTreeExpression);
-            }
-            const otherTypeTreeExpression = other;
-            // Visit expression
-            yield this.visit(typeTreeExpression.expression, otherTypeTreeExpression.expression);
-            return typeTreeExpression;
+            return this.visitElement(typeTreeExpression, other);
         });
     }
     /**
@@ -1433,16 +821,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitAs(as_, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== tree_1.JS.Kind.As) {
-                return this.abort(as_);
-            }
-            const otherAs = other;
-            // Visit left and right operands in lock step
-            yield this.visit(as_.left.element, otherAs.left.element);
-            if (!this.match)
-                return as_;
-            yield this.visit(as_.right, otherAs.right);
-            return as_;
+            return this.visitElement(as_, other);
         });
     }
     /**
@@ -1454,21 +833,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitAssignmentOperationExtensions(assignmentOperation, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== tree_1.JS.Kind.AssignmentOperation) {
-                return this.abort(assignmentOperation);
-            }
-            const otherAssignmentOperation = other;
-            // Visit variable
-            yield 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
-            yield this.visit(assignmentOperation.assignment, otherAssignmentOperation.assignment);
-            return assignmentOperation;
+            return this.visitElement(assignmentOperation, other);
         });
     }
     /**
@@ -1480,17 +845,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitIndexedAccessType(indexedAccessType, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== tree_1.JS.Kind.IndexedAccessType) {
-                return this.abort(indexedAccessType);
-            }
-            const otherIndexedAccessType = other;
-            // Visit object type
-            yield this.visit(indexedAccessType.objectType, otherIndexedAccessType.objectType);
-            if (!this.match)
-                return indexedAccessType;
-            // Visit index type
-            yield this.visit(indexedAccessType.indexType, otherIndexedAccessType.indexType);
-            return indexedAccessType;
+            return this.visitElement(indexedAccessType, other);
         });
     }
     /**
@@ -1502,13 +857,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitIndexedAccessTypeIndexType(indexType, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== tree_1.JS.Kind.IndexType) {
-                return this.abort(indexType);
-            }
-            const otherIndexType = other;
-            // Visit element
-            yield this.visit(indexType.element.element, otherIndexType.element.element);
-            return indexType;
+            return this.visitElement(indexType, other);
         });
     }
     /**
@@ -1520,30 +869,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitTypeQuery(typeQuery, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== tree_1.JS.Kind.TypeQuery) {
-                return this.abort(typeQuery);
-            }
-            const otherTypeQuery = other;
-            // Visit type expression
-            yield 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++) {
-                    yield this.visit(typeQuery.typeArguments.elements[i].element, otherTypeQuery.typeArguments.elements[i].element);
-                    if (!this.match)
-                        return typeQuery;
-                }
-            }
-            return typeQuery;
+            return this.visitElement(typeQuery, other);
         });
     }
     /**
@@ -1555,13 +881,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitTypeInfo(typeInfo, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== tree_1.JS.Kind.TypeInfo) {
-                return this.abort(typeInfo);
-            }
-            const otherTypeInfo = other;
-            // Visit type identifier
-            yield this.visit(typeInfo.typeIdentifier, otherTypeInfo.typeIdentifier);
-            return typeInfo;
+            return this.visitElement(typeInfo, other);
         });
     }
     /**
@@ -1573,13 +893,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitComputedPropertyName(computedPropertyName, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== tree_1.JS.Kind.ComputedPropertyName) {
-                return this.abort(computedPropertyName);
-            }
-            const otherComputedPropertyName = other;
-            // Visit expression
-            yield this.visit(computedPropertyName.expression.element, otherComputedPropertyName.expression.element);
-            return computedPropertyName;
+            return this.visitElement(computedPropertyName, other);
         });
     }
     /**
@@ -1591,13 +905,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitTypeOperator(typeOperator, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== tree_1.JS.Kind.TypeOperator) {
-                return this.abort(typeOperator);
-            }
-            const otherTypeOperator = other;
-            // Visit expression
-            yield this.visit(typeOperator.expression.element, otherTypeOperator.expression.element);
-            return typeOperator;
+            return this.visitElement(typeOperator, other);
         });
     }
     /**
@@ -1609,26 +917,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitTypePredicate(typePredicate, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== tree_1.JS.Kind.TypePredicate) {
-                return this.abort(typePredicate);
-            }
-            const otherTypePredicate = other;
-            // Compare asserts
-            if (typePredicate.asserts.element !== otherTypePredicate.asserts.element) {
-                return this.abort(typePredicate);
-            }
-            // Visit parameter name
-            yield 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) {
-                yield this.visit(typePredicate.expression.element, otherTypePredicate.expression.element);
-            }
-            return typePredicate;
+            return this.visitElement(typePredicate, other);
         });
     }
     /**
@@ -1640,21 +929,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitUnion(union, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== tree_1.JS.Kind.Union) {
-                return this.abort(union);
-            }
-            const otherUnion = other;
-            // 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++) {
-                yield this.visit(union.types[i].element, otherUnion.types[i].element);
-                if (!this.match)
-                    return union;
-            }
-            return union;
+            return this.visitElement(union, other);
         });
     }
     /**
@@ -1666,21 +941,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitIntersection(intersection, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== tree_1.JS.Kind.Intersection) {
-                return this.abort(intersection);
-            }
-            const otherIntersection = other;
-            // 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++) {
-                yield this.visit(intersection.types[i].element, otherIntersection.types[i].element);
-                if (!this.match)
-                    return intersection;
-            }
-            return intersection;
+            return this.visitElement(intersection, other);
         });
     }
     /**
@@ -1692,23 +953,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitAnnotatedType(annotatedType, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== java_1.J.Kind.AnnotatedType) {
-                return this.abort(annotatedType);
-            }
-            const otherAnnotatedType = other;
-            // 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++) {
-                yield this.visit(annotatedType.annotations[i], otherAnnotatedType.annotations[i]);
-                if (!this.match)
-                    return annotatedType;
-            }
-            // Visit type expression
-            yield this.visit(annotatedType.typeExpression, otherAnnotatedType.typeExpression);
-            return annotatedType;
+            return this.visitElement(annotatedType, other);
         });
     }
     /**
@@ -1720,31 +965,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitAnnotation(annotation, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== java_1.J.Kind.Annotation) {
-                return this.abort(annotation);
-            }
-            const otherAnnotation = other;
-            // Visit annotation type
-            yield 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++) {
-                    yield this.visit(annotation.arguments.elements[i].element, otherAnnotation.arguments.elements[i].element);
-                    if (!this.match)
-                        return annotation;
-                }
-            }
-            return annotation;
+            return this.visitElement(annotation, other);
         });
     }
     /**
@@ -1756,17 +977,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitArrayAccess(arrayAccess, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== java_1.J.Kind.ArrayAccess) {
-                return this.abort(arrayAccess);
-            }
-            const otherArrayAccess = other;
-            // Visit indexed expression
-            yield this.visit(arrayAccess.indexed, otherArrayAccess.indexed);
-            if (!this.match)
-                return arrayAccess;
-            // Visit dimension
-            yield this.visit(arrayAccess.dimension, otherArrayAccess.dimension);
-            return arrayAccess;
+            return this.visitElement(arrayAccess, other);
         });
     }
     /**
@@ -1778,19 +989,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitArrayDimension(arrayDimension, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== java_1.J.Kind.ArrayDimension) {
-                return this.abort(arrayDimension);
-            }
-            const otherArrayDimension = other;
-            // Visit index
-            if (arrayDimension.index && otherArrayDimension.index) {
-                yield 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);
         });
     }
     /**
@@ -1802,28 +1001,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitArrayType(arrayType, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b;
-            if (!this.match || other.kind !== java_1.J.Kind.ArrayType) {
-                return this.abort(arrayType);
-            }
-            const otherArrayType = other;
-            // Visit element type
-            yield this.visit(arrayType.elementType, otherArrayType.elementType);
-            if (!this.match)
-                return arrayType;
-            // Compare annotations
-            if ((((_a = arrayType.annotations) === null || _a === void 0 ? void 0 : _a.length) || 0) !== (((_b = otherArrayType.annotations) === null || _b === void 0 ? void 0 : _b.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++) {
-                    yield this.visit(arrayType.annotations[i], otherArrayType.annotations[i]);
-                    if (!this.match)
-                        return arrayType;
-                }
-            }
-            return arrayType;
+            return this.visitElement(arrayType, other);
         });
     }
     /**
@@ -1835,23 +1013,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitAssert(anAssert, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== java_1.J.Kind.Assert) {
-                return this.abort(anAssert);
-            }
-            const otherAssert = other;
-            // Visit condition
-            yield 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) {
-                yield this.visit(anAssert.detail.element, otherAssert.detail.element);
-            }
-            return anAssert;
+            return this.visitElement(anAssert, other);
         });
     }
     /**
@@ -1863,23 +1025,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitAssignment(assignment, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== java_1.J.Kind.Assignment) {
-                return this.abort(assignment);
-            }
-            const otherAssignment = other;
-            // Visit variable
-            yield this.visit(assignment.variable, otherAssignment.variable);
-            if (!this.match)
-                return assignment;
-            // Visit assignment
-            if (assignment.assignment && otherAssignment.assignment) {
-                yield 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);
         });
     }
     /**
@@ -1891,21 +1037,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitAssignmentOperation(assignOp, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== java_1.J.Kind.AssignmentOperation) {
-                return this.abort(assignOp);
-            }
-            const otherAssignOp = other;
-            // Visit variable
-            yield 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
-            yield this.visit(assignOp.assignment, otherAssignOp.assignment);
-            return assignOp;
+            return this.visitElement(assignOp, other);
         });
     }
     /**
@@ -1917,19 +1049,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitBreak(breakStatement, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== java_1.J.Kind.Break) {
-                return this.abort(breakStatement);
-            }
-            const otherBreak = other;
-            // Compare label presence
-            if ((breakStatement.label !== undefined) !== (otherBreak.label !== undefined)) {
-                return this.abort(breakStatement);
-            }
-            // Visit label if it exists
-            if (breakStatement.label && otherBreak.label) {
-                yield this.visit(breakStatement.label, otherBreak.label);
-            }
-            return breakStatement;
+            return this.visitElement(breakStatement, other);
         });
     }
     /**
@@ -1941,49 +1061,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitCase(aCase, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== java_1.J.Kind.Case) {
-                return this.abort(aCase);
-            }
-            const otherCase = other;
-            // 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++) {
-                yield 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++) {
-                yield 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) {
-                yield 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) {
-                yield this.visit(aCase.guard, otherCase.guard);
-            }
-            return aCase;
+            return this.visitElement(aCase, other);
         });
     }
     /**
@@ -1995,115 +1073,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitClassDeclaration(classDecl, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== java_1.J.Kind.ClassDeclaration) {
-                return this.abort(classDecl);
-            }
-            const otherClassDecl = other;
-            // 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++) {
-                yield 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++) {
-                yield this.visit(classDecl.modifiers[i], otherClassDecl.modifiers[i]);
-                if (!this.match)
-                    return classDecl;
-            }
-            // Visit class kind
-            yield this.visit(classDecl.classKind, otherClassDecl.classKind);
-            if (!this.match)
-                return classDecl;
-            // Visit name
-            yield 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++) {
-                    yield 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++) {
-                    yield 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) {
-                yield 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++) {
-                    yield 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++) {
-                    yield this.visit(classDecl.permitting.elements[i].element, otherClassDecl.permitting.elements[i].element);
-                    if (!this.match)
-                        return classDecl;
-                }
-            }
-            // Visit body
-            yield this.visit(classDecl.body, otherClassDecl.body);
-            return classDecl;
+            return this.visitElement(classDecl, other);
         });
     }
     /**
@@ -2115,21 +1085,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitClassDeclarationKind(kind, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== java_1.J.Kind.ClassDeclarationKind) {
-                return this.abort(kind);
-            }
-            const otherKind = other;
-            // 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++) {
-                yield this.visit(kind.annotations[i], otherKind.annotations[i]);
-                if (!this.match)
-                    return kind;
-            }
-            return kind;
+            return this.visitElement(kind, other);
         });
     }
     /**
@@ -2141,41 +1097,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitCompilationUnit(compilationUnit, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== java_1.J.Kind.CompilationUnit) {
-                return this.abort(compilationUnit);
-            }
-            const otherCompilationUnit = other;
-            // 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) {
-                yield 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++) {
-                yield 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++) {
-                yield this.visit(compilationUnit.classes[i], otherCompilationUnit.classes[i]);
-                if (!this.match)
-                    return compilationUnit;
-            }
-            return compilationUnit;
+            return this.visitElement(compilationUnit, other);
         });
     }
     /**
@@ -2187,19 +1109,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitContinue(continueStatement, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== java_1.J.Kind.Continue) {
-                return this.abort(continueStatement);
-            }
-            const otherContinue = other;
-            // Compare label presence
-            if ((continueStatement.label !== undefined) !== (otherContinue.label !== undefined)) {
-                return this.abort(continueStatement);
-            }
-            // Visit label if it exists
-            if (continueStatement.label && otherContinue.label) {
-                yield this.visit(continueStatement.label, otherContinue.label);
-            }
-            return continueStatement;
+            return this.visitElement(continueStatement, other);
         });
     }
     /**
@@ -2211,13 +1121,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitControlParentheses(controlParens, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== java_1.J.Kind.ControlParentheses) {
-                return this.abort(controlParens);
-            }
-            const otherControlParens = other;
-            // Visit tree
-            yield this.visit(controlParens.tree.element, otherControlParens.tree.element);
-            return controlParens;
+            return this.visitElement(controlParens, other);
         });
     }
     /**
@@ -2229,25 +1133,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitDeconstructionPattern(pattern, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== java_1.J.Kind.DeconstructionPattern) {
-                return this.abort(pattern);
-            }
-            const otherPattern = other;
-            // Visit deconstructor
-            yield 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++) {
-                yield this.visit(pattern.nested.elements[i].element, otherPattern.nested.elements[i].element);
-                if (!this.match)
-                    return pattern;
-            }
-            return pattern;
+            return this.visitElement(pattern, other);
         });
     }
     /**
@@ -2259,17 +1145,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitDoWhileLoop(doWhileLoop, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== java_1.J.Kind.DoWhileLoop) {
-                return this.abort(doWhileLoop);
-            }
-            const otherDoWhileLoop = other;
-            // Visit body
-            yield this.visit(doWhileLoop.body.element, otherDoWhileLoop.body.element);
-            if (!this.match)
-                return doWhileLoop;
-            // Visit while condition
-            yield this.visit(doWhileLoop.whileCondition.element, otherDoWhileLoop.whileCondition.element);
-            return doWhileLoop;
+            return this.visitElement(doWhileLoop, other);
         });
     }
     /**
@@ -2281,11 +1157,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitEmpty(empty, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== java_1.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);
         });
     }
     /**
@@ -2297,33 +1169,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitEnumValue(enumValue, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== java_1.J.Kind.EnumValue) {
-                return this.abort(enumValue);
-            }
-            const otherEnumValue = other;
-            // 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++) {
-                yield this.visit(enumValue.annotations[i], otherEnumValue.annotations[i]);
-                if (!this.match)
-                    return enumValue;
-            }
-            // Visit name
-            yield 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) {
-                yield this.visit(enumValue.initializer, otherEnumValue.initializer);
-            }
-            return enumValue;
+            return this.visitElement(enumValue, other);
         });
     }
     /**
@@ -2335,21 +1181,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitEnumValueSet(enumValueSet, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== java_1.J.Kind.EnumValueSet) {
-                return this.abort(enumValueSet);
-            }
-            const otherEnumValueSet = other;
-            // 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++) {
-                yield this.visit(enumValueSet.enums[i].element, otherEnumValueSet.enums[i].element);
-                if (!this.match)
-                    return enumValueSet;
-            }
-            return enumValueSet;
+            return this.visitElement(enumValueSet, other);
         });
     }
     /**
@@ -2361,15 +1193,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitErroneous(erroneous, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== java_1.J.Kind.Erroneous) {
-                return this.abort(erroneous);
-            }
-            const otherErroneous = other;
-            // Compare text
-            if (erroneous.text !== otherErroneous.text) {
-                return this.abort(erroneous);
-            }
-            return erroneous;
+            return this.visitElement(erroneous, other);
         });
     }
     /**
@@ -2381,19 +1205,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitFieldAccess(fieldAccess, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== java_1.J.Kind.FieldAccess) {
-                return this.abort(fieldAccess);
-            }
-            const otherFieldAccess = other;
-            // Visit target
-            yield this.visit(fieldAccess.target, otherFieldAccess.target);
-            if (!this.match)
-                return fieldAccess;
-            // Visit name
-            yield this.visit(fieldAccess.name.element, otherFieldAccess.name.element);
-            if (!this.match)
-                return fieldAccess;
-            return fieldAccess;
+            return this.visitElement(fieldAccess, other);
         });
     }
     /**
@@ -2405,19 +1217,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitForEachLoop(forEachLoop, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== java_1.J.Kind.ForEachLoop) {
-                return this.abort(forEachLoop);
-            }
-            const otherForEachLoop = other;
-            // Visit control
-            yield this.visit(forEachLoop.control, otherForEachLoop.control);
-            if (!this.match)
-                return forEachLoop;
-            // Visit body
-            yield this.visit(forEachLoop.body.element, otherForEachLoop.body.element);
-            if (!this.match)
-                return forEachLoop;
-            return forEachLoop;
+            return this.visitElement(forEachLoop, other);
         });
     }
     /**
@@ -2429,19 +1229,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitForEachLoopControl(control, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== java_1.J.Kind.ForEachLoopControl) {
-                return this.abort(control);
-            }
-            const otherControl = other;
-            // Visit variable
-            yield this.visit(control.variable.element, otherControl.variable.element);
-            if (!this.match)
-                return control;
-            // Visit iterable
-            yield this.visit(control.iterable.element, otherControl.iterable.element);
-            if (!this.match)
-                return control;
-            return control;
+            return this.visitElement(control, other);
         });
     }
     /**
@@ -2453,19 +1241,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitForLoop(forLoop, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== java_1.J.Kind.ForLoop) {
-                return this.abort(forLoop);
-            }
-            const otherForLoop = other;
-            // Visit control
-            yield this.visit(forLoop.control, otherForLoop.control);
-            if (!this.match)
-                return forLoop;
-            // Visit body
-            yield this.visit(forLoop.body.element, otherForLoop.body.element);
-            if (!this.match)
-                return forLoop;
-            return forLoop;
+            return this.visitElement(forLoop, other);
         });
     }
     /**
@@ -2477,41 +1253,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitForLoopControl(control, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== java_1.J.Kind.ForLoopControl) {
-                return this.abort(control);
-            }
-            const otherControl = other;
-            // 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++) {
-                yield 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) {
-                yield 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++) {
-                yield this.visit(control.update[i].element, otherControl.update[i].element);
-                if (!this.match)
-                    return control;
-            }
-            return control;
+            return this.visitElement(control, other);
         });
     }
     /**
@@ -2523,29 +1265,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitIf(ifStatement, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== java_1.J.Kind.If) {
-                return this.abort(ifStatement);
-            }
-            const otherIfStatement = other;
-            // Visit condition
-            yield this.visit(ifStatement.ifCondition, otherIfStatement.ifCondition);
-            if (!this.match)
-                return ifStatement;
-            // Visit then part
-            yield 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) {
-                yield this.visit(ifStatement.elsePart, otherIfStatement.elsePart);
-                if (!this.match)
-                    return ifStatement;
-            }
-            return ifStatement;
+            return this.visitElement(ifStatement, other);
         });
     }
     /**
@@ -2557,15 +1277,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitElse(elseStatement, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== java_1.J.Kind.IfElse) {
-                return this.abort(elseStatement);
-            }
-            const otherElseStatement = other;
-            // Visit body
-            yield this.visit(elseStatement.body.element, otherElseStatement.body.element);
-            if (!this.match)
-                return elseStatement;
-            return elseStatement;
+            return this.visitElement(elseStatement, other);
         });
     }
     /**
@@ -2577,29 +1289,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitImport(importStatement, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== java_1.J.Kind.Import) {
-                return this.abort(importStatement);
-            }
-            const otherImportStatement = other;
-            // Compare static
-            if (importStatement.static.element !== otherImportStatement.static.element) {
-                return this.abort(importStatement);
-            }
-            // Visit qualid
-            yield 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) {
-                yield this.visit(importStatement.alias.element, otherImportStatement.alias.element);
-                if (!this.match)
-                    return importStatement;
-            }
-            return importStatement;
+            return this.visitElement(importStatement, other);
         });
     }
     /**
@@ -2611,39 +1301,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitInstanceOf(instanceOf, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== java_1.J.Kind.InstanceOf) {
-                return this.abort(instanceOf);
-            }
-            const otherInstanceOf = other;
-            // Visit expression
-            yield this.visit(instanceOf.expression.element, otherInstanceOf.expression.element);
-            if (!this.match)
-                return instanceOf;
-            // Visit class
-            yield 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) {
-                yield 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) {
-                yield this.visit(instanceOf.modifier, otherInstanceOf.modifier);
-                if (!this.match)
-                    return instanceOf;
-            }
-            return instanceOf;
+            return this.visitElement(instanceOf, other);
         });
     }
     /**
@@ -2655,21 +1313,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitIntersectionType(intersectionType, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== java_1.J.Kind.IntersectionType) {
-                return this.abort(intersectionType);
-            }
-            const otherIntersectionType = other;
-            // 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++) {
-                yield this.visit(intersectionType.bounds.elements[i].element, otherIntersectionType.bounds.elements[i].element);
-                if (!this.match)
-                    return intersectionType;
-            }
-            return intersectionType;
+            return this.visitElement(intersectionType, other);
         });
     }
     /**
@@ -2681,19 +1325,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitLabel(label, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== java_1.J.Kind.Label) {
-                return this.abort(label);
-            }
-            const otherLabel = other;
-            // Visit label identifier
-            yield this.visit(label.label.element, otherLabel.label.element);
-            if (!this.match)
-                return label;
-            // Visit statement
-            yield this.visit(label.statement, otherLabel.statement);
-            if (!this.match)
-                return label;
-            return label;
+            return this.visitElement(label, other);
         });
     }
     /**
@@ -2705,19 +1337,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitLambda(lambda, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== java_1.J.Kind.Lambda) {
-                return this.abort(lambda);
-            }
-            const otherLambda = other;
-            // Visit parameters
-            yield this.visit(lambda.parameters, otherLambda.parameters);
-            if (!this.match)
-                return lambda;
-            // Visit body
-            yield this.visit(lambda.body, otherLambda.body);
-            if (!this.match)
-                return lambda;
-            return lambda;
+            return this.visitElement(lambda, other);
         });
     }
     /**
@@ -2729,25 +1349,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitLambdaParameters(parameters, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== java_1.J.Kind.LambdaParameters) {
-                return this.abort(parameters);
-            }
-            const otherParameters = other;
-            // 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++) {
-                yield this.visit(parameters.parameters[i].element, otherParameters.parameters[i].element);
-                if (!this.match)
-                    return parameters;
-            }
-            return parameters;
+            return this.visitElement(parameters, other);
         });
     }
     /**
@@ -2759,35 +1361,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitMemberReference(memberReference, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== java_1.J.Kind.MemberReference) {
-                return this.abort(memberReference);
-            }
-            const otherMemberReference = other;
-            // Visit containing
-            yield 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++) {
-                    yield this.visit(memberReference.typeParameters.elements[i].element, otherMemberReference.typeParameters.elements[i].element);
-                    if (!this.match)
-                        return memberReference;
-                }
-            }
-            // Visit reference
-            yield this.visit(memberReference.reference.element, otherMemberReference.reference.element);
-            if (!this.match)
-                return memberReference;
-            return memberReference;
+            return this.visitElement(memberReference, other);
         });
     }
     /**
@@ -2799,111 +1373,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitMethodDeclaration(methodDeclaration, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== java_1.J.Kind.MethodDeclaration) {
-                return this.abort(methodDeclaration);
-            }
-            const otherMethodDeclaration = other;
-            // 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++) {
-                yield 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++) {
-                yield 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) {
-                yield 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) {
-                yield 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++) {
-                yield this.visit(methodDeclaration.nameAnnotations[i], otherMethodDeclaration.nameAnnotations[i]);
-                if (!this.match)
-                    return methodDeclaration;
-            }
-            // Visit name
-            yield 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++) {
-                yield 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++) {
-                    yield 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) {
-                yield 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) {
-                yield this.visit(methodDeclaration.defaultValue.element, otherMethodDeclaration.defaultValue.element);
-                if (!this.match)
-                    return methodDeclaration;
-            }
-            return methodDeclaration;
+            return this.visitElement(methodDeclaration, other);
         });
     }
     /**
@@ -2915,51 +1385,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitMethodInvocation(methodInvocation, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== java_1.J.Kind.MethodInvocation) {
-                return this.abort(methodInvocation);
-            }
-            const otherMethodInvocation = other;
-            // Compare select
-            if ((methodInvocation.select === undefined) !== (otherMethodInvocation.select === undefined)) {
-                return this.abort(methodInvocation);
-            }
-            // Visit select if present
-            if (methodInvocation.select && otherMethodInvocation.select) {
-                yield 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++) {
-                    yield this.visit(methodInvocation.typeParameters.elements[i].element, otherMethodInvocation.typeParameters.elements[i].element);
-                    if (!this.match)
-                        return methodInvocation;
-                }
-            }
-            // Visit name
-            yield 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++) {
-                yield this.visit(methodInvocation.arguments.elements[i].element, otherMethodInvocation.arguments.elements[i].element);
-                if (!this.match)
-                    return methodInvocation;
-            }
-            return methodInvocation;
+            return this.visitElement(methodInvocation, other);
         });
     }
     /**
@@ -2971,29 +1397,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitModifier(modifier, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== java_1.J.Kind.Modifier) {
-                return this.abort(modifier);
-            }
-            const otherModifier = other;
-            // 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++) {
-                yield this.visit(modifier.annotations[i], otherModifier.annotations[i]);
-                if (!this.match)
-                    return modifier;
-            }
-            return modifier;
+            return this.visitElement(modifier, other);
         });
     }
     /**
@@ -3005,21 +1409,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitMultiCatch(multiCatch, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== java_1.J.Kind.MultiCatch) {
-                return this.abort(multiCatch);
-            }
-            const otherMultiCatch = other;
-            // 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++) {
-                yield this.visit(multiCatch.alternatives[i].element, otherMultiCatch.alternatives[i].element);
-                if (!this.match)
-                    return multiCatch;
-            }
-            return multiCatch;
+            return this.visitElement(multiCatch, other);
         });
     }
     /**
@@ -3031,47 +1421,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitNewArray(newArray, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== java_1.J.Kind.NewArray) {
-                return this.abort(newArray);
-            }
-            const otherNewArray = other;
-            // Compare typeExpression
-            if ((newArray.typeExpression === undefined) !== (otherNewArray.typeExpression === undefined)) {
-                return this.abort(newArray);
-            }
-            // Visit typeExpression if present
-            if (newArray.typeExpression && otherNewArray.typeExpression) {
-                yield 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++) {
-                yield 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++) {
-                    yield this.visit(newArray.initializer.elements[i].element, otherNewArray.initializer.elements[i].element);
-                    if (!this.match)
-                        return newArray;
-                }
-            }
-            return newArray;
+            return this.visitElement(newArray, other);
         });
     }
     /**
@@ -3083,51 +1433,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitNewClass(newClass, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== java_1.J.Kind.NewClass) {
-                return this.abort(newClass);
-            }
-            const otherNewClass = other;
-            // Compare enclosing
-            if ((newClass.enclosing === undefined) !== (otherNewClass.enclosing === undefined)) {
-                return this.abort(newClass);
-            }
-            // Visit enclosing if present
-            if (newClass.enclosing && otherNewClass.enclosing) {
-                yield 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) {
-                yield 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++) {
-                yield 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) {
-                yield this.visit(newClass.body, otherNewClass.body);
-                if (!this.match)
-                    return newClass;
-            }
-            return newClass;
+            return this.visitElement(newClass, other);
         });
     }
     /**
@@ -3139,25 +1445,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitNullableType(nullableType, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== java_1.J.Kind.NullableType) {
-                return this.abort(nullableType);
-            }
-            const otherNullableType = other;
-            // 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++) {
-                yield this.visit(nullableType.annotations[i], otherNullableType.annotations[i]);
-                if (!this.match)
-                    return nullableType;
-            }
-            // Visit typeTree
-            yield this.visit(nullableType.typeTree.element, otherNullableType.typeTree.element);
-            if (!this.match)
-                return nullableType;
-            return nullableType;
+            return this.visitElement(nullableType, other);
         });
     }
     /**
@@ -3169,31 +1457,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitPackage(packageDeclaration, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== java_1.J.Kind.Package) {
-                return this.abort(packageDeclaration);
-            }
-            const otherPackageDeclaration = other;
-            // Visit expression
-            yield 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++) {
-                    yield this.visit(packageDeclaration.annotations[i], otherPackageDeclaration.annotations[i]);
-                    if (!this.match)
-                        return packageDeclaration;
-                }
-            }
-            return packageDeclaration;
+            return this.visitElement(packageDeclaration, other);
         });
     }
     /**
@@ -3205,31 +1469,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitParameterizedType(parameterizedType, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== java_1.J.Kind.ParameterizedType) {
-                return this.abort(parameterizedType);
-            }
-            const otherParameterizedType = other;
-            // Visit class
-            yield 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++) {
-                    yield this.visit(parameterizedType.typeParameters.elements[i].element, otherParameterizedType.typeParameters.elements[i].element);
-                    if (!this.match)
-                        return parameterizedType;
-                }
-            }
-            return parameterizedType;
+            return this.visitElement(parameterizedType, other);
         });
     }
     /**
@@ -3241,15 +1481,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitParentheses(parentheses, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== java_1.J.Kind.Parentheses) {
-                return this.abort(parentheses);
-            }
-            const otherParentheses = other;
-            // Visit tree
-            yield this.visit(parentheses.tree.element, otherParentheses.tree.element);
-            if (!this.match)
-                return parentheses;
-            return parentheses;
+            return this.visitElement(parentheses, other);
         });
     }
     /**
@@ -3261,25 +1493,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitParenthesizedTypeTree(parenthesizedTypeTree, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== java_1.J.Kind.ParenthesizedTypeTree) {
-                return this.abort(parenthesizedTypeTree);
-            }
-            const otherParenthesizedTypeTree = other;
-            // 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++) {
-                yield this.visit(parenthesizedTypeTree.annotations[i], otherParenthesizedTypeTree.annotations[i]);
-                if (!this.match)
-                    return parenthesizedTypeTree;
-            }
-            // Visit parenthesizedType
-            yield this.visit(parenthesizedTypeTree.parenthesizedType, otherParenthesizedTypeTree.parenthesizedType);
-            if (!this.match)
-                return parenthesizedTypeTree;
-            return parenthesizedTypeTree;
+            return this.visitElement(parenthesizedTypeTree, other);
         });
     }
     /**
@@ -3291,15 +1505,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitPrimitive(primitive, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== java_1.J.Kind.Primitive) {
-                return this.abort(primitive);
-            }
-            const otherPrimitive = other;
-            // Compare type
-            if (primitive.type.kind !== otherPrimitive.type.kind) {
-                return this.abort(primitive);
-            }
-            return primitive;
+            return this.visitElement(primitive, other);
         });
     }
     /**
@@ -3311,21 +1517,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitReturn(returnStatement, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== java_1.J.Kind.Return) {
-                return this.abort(returnStatement);
-            }
-            const otherReturnStatement = other;
-            // Compare expression
-            if ((returnStatement.expression === undefined) !== (otherReturnStatement.expression === undefined)) {
-                return this.abort(returnStatement);
-            }
-            // Visit expression if present
-            if (returnStatement.expression && otherReturnStatement.expression) {
-                yield this.visit(returnStatement.expression, otherReturnStatement.expression);
-                if (!this.match)
-                    return returnStatement;
-            }
-            return returnStatement;
+            return this.visitElement(returnStatement, other);
         });
     }
     /**
@@ -3337,19 +1529,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitSwitch(switchStatement, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== java_1.J.Kind.Switch) {
-                return this.abort(switchStatement);
-            }
-            const otherSwitchStatement = other;
-            // Visit selector
-            yield this.visit(switchStatement.selector, otherSwitchStatement.selector);
-            if (!this.match)
-                return switchStatement;
-            // Visit cases
-            yield this.visit(switchStatement.cases, otherSwitchStatement.cases);
-            if (!this.match)
-                return switchStatement;
-            return switchStatement;
+            return this.visitElement(switchStatement, other);
         });
     }
     /**
@@ -3361,19 +1541,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitSwitchExpression(switchExpression, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== java_1.J.Kind.SwitchExpression) {
-                return this.abort(switchExpression);
-            }
-            const otherSwitchExpression = other;
-            // Visit selector
-            yield this.visit(switchExpression.selector, otherSwitchExpression.selector);
-            if (!this.match)
-                return switchExpression;
-            // Visit cases
-            yield this.visit(switchExpression.cases, otherSwitchExpression.cases);
-            if (!this.match)
-                return switchExpression;
-            return switchExpression;
+            return this.visitElement(switchExpression, other);
         });
     }
     /**
@@ -3385,19 +1553,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitSynchronized(synchronizedStatement, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== java_1.J.Kind.Synchronized) {
-                return this.abort(synchronizedStatement);
-            }
-            const otherSynchronizedStatement = other;
-            // Visit lock
-            yield this.visit(synchronizedStatement.lock, otherSynchronizedStatement.lock);
-            if (!this.match)
-                return synchronizedStatement;
-            // Visit body
-            yield this.visit(synchronizedStatement.body, otherSynchronizedStatement.body);
-            if (!this.match)
-                return synchronizedStatement;
-            return synchronizedStatement;
+            return this.visitElement(synchronizedStatement, other);
         });
     }
     /**
@@ -3409,23 +1565,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitTernary(ternary, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== java_1.J.Kind.Ternary) {
-                return this.abort(ternary);
-            }
-            const otherTernary = other;
-            // Visit condition
-            yield this.visit(ternary.condition, otherTernary.condition);
-            if (!this.match)
-                return ternary;
-            // Visit truePart
-            yield this.visit(ternary.truePart.element, otherTernary.truePart.element);
-            if (!this.match)
-                return ternary;
-            // Visit falsePart
-            yield this.visit(ternary.falsePart.element, otherTernary.falsePart.element);
-            if (!this.match)
-                return ternary;
-            return ternary;
+            return this.visitElement(ternary, other);
         });
     }
     /**
@@ -3437,15 +1577,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitThrow(throwStatement, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== java_1.J.Kind.Throw) {
-                return this.abort(throwStatement);
-            }
-            const otherThrowStatement = other;
-            // Visit exception
-            yield this.visit(throwStatement.exception, otherThrowStatement.exception);
-            if (!this.match)
-                return throwStatement;
-            return throwStatement;
+            return this.visitElement(throwStatement, other);
         });
     }
     /**
@@ -3457,51 +1589,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitTry(tryStatement, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== java_1.J.Kind.Try) {
-                return this.abort(tryStatement);
-            }
-            const otherTryStatement = other;
-            // 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++) {
-                    yield this.visit(tryStatement.resources.elements[i].element, otherTryStatement.resources.elements[i].element);
-                    if (!this.match)
-                        return tryStatement;
-                }
-            }
-            // Visit body
-            yield 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++) {
-                yield 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) {
-                yield this.visit(tryStatement.finally.element, otherTryStatement.finally.element);
-                if (!this.match)
-                    return tryStatement;
-            }
-            return tryStatement;
+            return this.visitElement(tryStatement, other);
         });
     }
     /**
@@ -3513,19 +1601,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitTryResource(resource, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== java_1.J.Kind.TryResource) {
-                return this.abort(resource);
-            }
-            const otherResource = other;
-            // Visit variableDeclarations
-            yield 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);
         });
     }
     /**
@@ -3537,19 +1613,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitTryCatch(tryCatch, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== java_1.J.Kind.TryCatch) {
-                return this.abort(tryCatch);
-            }
-            const otherTryCatch = other;
-            // Visit parameter
-            yield this.visit(tryCatch.parameter, otherTryCatch.parameter);
-            if (!this.match)
-                return tryCatch;
-            // Visit body
-            yield this.visit(tryCatch.body, otherTryCatch.body);
-            if (!this.match)
-                return tryCatch;
-            return tryCatch;
+            return this.visitElement(tryCatch, other);
         });
     }
     /**
@@ -3561,19 +1625,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitTypeCast(typeCast, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== java_1.J.Kind.TypeCast) {
-                return this.abort(typeCast);
-            }
-            const otherTypeCast = other;
-            // Visit class
-            yield this.visit(typeCast.class, otherTypeCast.class);
-            if (!this.match)
-                return typeCast;
-            // Visit expression
-            yield this.visit(typeCast.expression, otherTypeCast.expression);
-            if (!this.match)
-                return typeCast;
-            return typeCast;
+            return this.visitElement(typeCast, other);
         });
     }
     /**
@@ -3585,51 +1637,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitTypeParameter(typeParameter, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== java_1.J.Kind.TypeParameter) {
-                return this.abort(typeParameter);
-            }
-            const otherTypeParameter = other;
-            // 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++) {
-                yield 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++) {
-                yield this.visit(typeParameter.modifiers[i], otherTypeParameter.modifiers[i]);
-                if (!this.match)
-                    return typeParameter;
-            }
-            // Visit name
-            yield 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++) {
-                    yield this.visit(typeParameter.bounds.elements[i].element, otherTypeParameter.bounds.elements[i].element);
-                    if (!this.match)
-                        return typeParameter;
-                }
-            }
-            return typeParameter;
+            return this.visitElement(typeParameter, other);
         });
     }
     /**
@@ -3641,31 +1649,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitTypeParameters(typeParameters, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== java_1.J.Kind.TypeParameters) {
-                return this.abort(typeParameters);
-            }
-            const otherTypeParameters = other;
-            // 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++) {
-                yield 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++) {
-                yield this.visit(typeParameters.typeParameters[i].element, otherTypeParameters.typeParameters[i].element);
-                if (!this.match)
-                    return typeParameters;
-            }
-            return typeParameters;
+            return this.visitElement(typeParameters, other);
         });
     }
     /**
@@ -3677,19 +1661,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitUnary(unary, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== java_1.J.Kind.Unary) {
-                return this.abort(unary);
-            }
-            const otherUnary = other;
-            // Compare operator
-            if (unary.operator.element !== otherUnary.operator.element) {
-                return this.abort(unary);
-            }
-            // Visit expression
-            yield this.visit(unary.expression, otherUnary.expression);
-            if (!this.match)
-                return unary;
-            return unary;
+            return this.visitElement(unary, other);
         });
     }
     /**
@@ -3701,15 +1673,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitUnknown(unknown, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== java_1.J.Kind.Unknown) {
-                return this.abort(unknown);
-            }
-            const otherUnknown = other;
-            // Visit source
-            yield this.visit(unknown.source, otherUnknown.source);
-            if (!this.match)
-                return unknown;
-            return unknown;
+            return this.visitElement(unknown, other);
         });
     }
     /**
@@ -3721,75 +1685,19 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitUnknownSource(unknownSource, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== java_1.J.Kind.UnknownSource) {
-                return this.abort(unknownSource);
-            }
-            const otherUnknownSource = other;
-            // Compare text
-            if (unknownSource.text !== otherUnknownSource.text) {
-                return this.abort(unknownSource);
-            }
-            return unknownSource;
+            return this.visitElement(unknownSource, other);
         });
     }
     /**
      * Overrides the visitVariableDeclarations method to compare variable declarations.
      *
-     * @param variableDeclarations The variable declarations to visit
-     * @param other The other variable declarations to compare with
-     * @returns The visited variable declarations, or undefined if the visit was aborted
-     */
-    visitVariableDeclarations(variableDeclarations, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== java_1.J.Kind.VariableDeclarations) {
-                return this.abort(variableDeclarations);
-            }
-            const otherVariableDeclarations = other;
-            // 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++) {
-                yield 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++) {
-                yield 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) {
-                yield 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++) {
-                yield this.visit(variableDeclarations.variables[i].element, otherVariableDeclarations.variables[i].element);
-                if (!this.match)
-                    return variableDeclarations;
-            }
-            return variableDeclarations;
+     * @param variableDeclarations The variable declarations to visit
+     * @param other The other variable declarations to compare with
+     * @returns The visited variable declarations, or undefined if the visit was aborted
+     */
+    visitVariableDeclarations(variableDeclarations, other) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.visitElement(variableDeclarations, other);
         });
     }
     /**
@@ -3801,29 +1709,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitVariable(variable, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== java_1.J.Kind.NamedVariable) {
-                return this.abort(variable);
-            }
-            const otherVariable = other;
-            // Visit name
-            yield 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) {
-                yield this.visit(variable.initializer.element, otherVariable.initializer.element);
-                if (!this.match)
-                    return variable;
-            }
-            return variable;
+            return this.visitElement(variable, other);
         });
     }
     /**
@@ -3835,19 +1721,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitWhileLoop(whileLoop, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== java_1.J.Kind.WhileLoop) {
-                return this.abort(whileLoop);
-            }
-            const otherWhileLoop = other;
-            // Visit condition
-            yield this.visit(whileLoop.condition, otherWhileLoop.condition);
-            if (!this.match)
-                return whileLoop;
-            // Visit body
-            yield this.visit(whileLoop.body.element, otherWhileLoop.body.element);
-            if (!this.match)
-                return whileLoop;
-            return whileLoop;
+            return this.visitElement(whileLoop, other);
         });
     }
     /**
@@ -3859,31 +1733,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitWildcard(wildcard, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== java_1.J.Kind.Wildcard) {
-                return this.abort(wildcard);
-            }
-            const otherWildcard = other;
-            // 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) {
-                yield this.visit(wildcard.boundedType, otherWildcard.boundedType);
-                if (!this.match)
-                    return wildcard;
-            }
-            return wildcard;
+            return this.visitElement(wildcard, other);
         });
     }
     /**
@@ -3895,19 +1745,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitYield(yieldStatement, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== java_1.J.Kind.Yield) {
-                return this.abort(yieldStatement);
-            }
-            const otherYieldStatement = other;
-            // Compare implicit
-            if (yieldStatement.implicit !== otherYieldStatement.implicit) {
-                return this.abort(yieldStatement);
-            }
-            // Visit value
-            yield this.visit(yieldStatement.value, otherYieldStatement.value);
-            if (!this.match)
-                return yieldStatement;
-            return yieldStatement;
+            return this.visitElement(yieldStatement, other);
         });
     }
     /**
@@ -3919,13 +1757,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitVoid(void_, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== tree_1.JS.Kind.Void) {
-                return this.abort(void_);
-            }
-            const otherVoid = other;
-            // Visit expression
-            yield this.visit(void_.expression, otherVoid.expression);
-            return void_;
+            return this.visitElement(void_, other);
         });
     }
     /**
@@ -3937,17 +1769,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitWithStatement(withStatement, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== tree_1.JS.Kind.WithStatement) {
-                return this.abort(withStatement);
-            }
-            const otherWithStatement = other;
-            // Visit expression
-            yield this.visit(withStatement.expression, otherWithStatement.expression);
-            if (!this.match)
-                return withStatement;
-            // Visit body
-            yield this.visit(withStatement.body.element, otherWithStatement.body.element);
-            return withStatement;
+            return this.visitElement(withStatement, other);
         });
     }
     /**
@@ -3959,33 +1781,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitIndexSignatureDeclaration(indexSignatureDeclaration, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== tree_1.JS.Kind.IndexSignatureDeclaration) {
-                return this.abort(indexSignatureDeclaration);
-            }
-            const otherIndexSignatureDeclaration = other;
-            // 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++) {
-                yield 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++) {
-                yield this.visit(indexSignatureDeclaration.parameters.elements[i].element, otherIndexSignatureDeclaration.parameters.elements[i].element);
-                if (!this.match)
-                    return indexSignatureDeclaration;
-            }
-            // Visit type expression
-            yield this.visit(indexSignatureDeclaration.typeExpression.element, otherIndexSignatureDeclaration.typeExpression.element);
-            return indexSignatureDeclaration;
+            return this.visitElement(indexSignatureDeclaration, other);
         });
     }
     /**
@@ -3997,19 +1793,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitForOfLoop(forOfLoop, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== tree_1.JS.Kind.ForOfLoop) {
-                return this.abort(forOfLoop);
-            }
-            const otherForOfLoop = other;
-            // Compare await
-            if ((forOfLoop.await === undefined) !== (otherForOfLoop.await === undefined)) {
-                return this.abort(forOfLoop);
-            }
-            // Visit loop
-            yield this.visit(forOfLoop.loop, otherForOfLoop.loop);
-            if (!this.match)
-                return forOfLoop;
-            return forOfLoop;
+            return this.visitElement(forOfLoop, other);
         });
     }
     /**
@@ -4021,19 +1805,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitForInLoop(forInLoop, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== tree_1.JS.Kind.ForInLoop) {
-                return this.abort(forInLoop);
-            }
-            const otherForInLoop = other;
-            // Visit control
-            yield this.visit(forInLoop.control, otherForInLoop.control);
-            if (!this.match)
-                return forInLoop;
-            // Visit body
-            yield this.visit(forInLoop.body.element, otherForInLoop.body.element);
-            if (!this.match)
-                return forInLoop;
-            return forInLoop;
+            return this.visitElement(forInLoop, other);
         });
     }
     /**
@@ -4045,39 +1817,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitNamespaceDeclaration(namespaceDeclaration, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== tree_1.JS.Kind.NamespaceDeclaration) {
-                return this.abort(namespaceDeclaration);
-            }
-            const otherNamespaceDeclaration = other;
-            // 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++) {
-                yield 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
-            yield 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) {
-                yield this.visit(namespaceDeclaration.body, otherNamespaceDeclaration.body);
-                if (!this.match)
-                    return namespaceDeclaration;
-            }
-            return namespaceDeclaration;
+            return this.visitElement(namespaceDeclaration, other);
         });
     }
     /**
@@ -4089,15 +1829,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitTypeLiteral(typeLiteral, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== tree_1.JS.Kind.TypeLiteral) {
-                return this.abort(typeLiteral);
-            }
-            const otherTypeLiteral = other;
-            // Visit members
-            yield this.visit(typeLiteral.members, otherTypeLiteral.members);
-            if (!this.match)
-                return typeLiteral;
-            return typeLiteral;
+            return this.visitElement(typeLiteral, other);
         });
     }
     /**
@@ -4109,35 +1841,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitBindingElement(bindingElement, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== tree_1.JS.Kind.BindingElement) {
-                return this.abort(bindingElement);
-            }
-            const otherBindingElement = other;
-            // Compare propertyName
-            if ((bindingElement.propertyName === undefined) !== (otherBindingElement.propertyName === undefined)) {
-                return this.abort(bindingElement);
-            }
-            // Visit propertyName if present
-            if (bindingElement.propertyName && otherBindingElement.propertyName) {
-                yield this.visit(bindingElement.propertyName.element, otherBindingElement.propertyName.element);
-                if (!this.match)
-                    return bindingElement;
-            }
-            // Visit name
-            yield 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) {
-                yield this.visit(bindingElement.initializer.element, otherBindingElement.initializer.element);
-                if (!this.match)
-                    return bindingElement;
-            }
-            return bindingElement;
+            return this.visitElement(bindingElement, other);
         });
     }
     /**
@@ -4149,21 +1853,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitArrayBindingPattern(arrayBindingPattern, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== tree_1.JS.Kind.ArrayBindingPattern) {
-                return this.abort(arrayBindingPattern);
-            }
-            const otherArrayBindingPattern = other;
-            // 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++) {
-                yield this.visit(arrayBindingPattern.elements.elements[i].element, otherArrayBindingPattern.elements.elements[i].element);
-                if (!this.match)
-                    return arrayBindingPattern;
-            }
-            return arrayBindingPattern;
+            return this.visitElement(arrayBindingPattern, other);
         });
     }
     /**
@@ -4175,55 +1865,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitExportDeclaration(exportDeclaration, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== tree_1.JS.Kind.ExportDeclaration) {
-                return this.abort(exportDeclaration);
-            }
-            const otherExportDeclaration = other;
-            // 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++) {
-                yield 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) {
-                yield 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) {
-                yield 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) {
-                yield this.visit(exportDeclaration.attributes, otherExportDeclaration.attributes);
-                if (!this.match)
-                    return exportDeclaration;
-            }
-            return exportDeclaration;
+            return this.visitElement(exportDeclaration, other);
         });
     }
     /**
@@ -4235,19 +1877,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitExportAssignment(exportAssignment, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== tree_1.JS.Kind.ExportAssignment) {
-                return this.abort(exportAssignment);
-            }
-            const otherExportAssignment = other;
-            // Compare exportEquals
-            if (exportAssignment.exportEquals !== otherExportAssignment.exportEquals) {
-                return this.abort(exportAssignment);
-            }
-            // Visit expression
-            yield this.visit(exportAssignment.expression.element, otherExportAssignment.expression.element);
-            if (!this.match)
-                return exportAssignment;
-            return exportAssignment;
+            return this.visitElement(exportAssignment, other);
         });
     }
     /**
@@ -4259,21 +1889,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitNamedExports(namedExports, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== tree_1.JS.Kind.NamedExports) {
-                return this.abort(namedExports);
-            }
-            const otherNamedExports = other;
-            // 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++) {
-                yield this.visit(namedExports.elements.elements[i].element, otherNamedExports.elements.elements[i].element);
-                if (!this.match)
-                    return namedExports;
-            }
-            return namedExports;
+            return this.visitElement(namedExports, other);
         });
     }
     /**
@@ -4285,19 +1901,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitExportSpecifier(exportSpecifier, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== tree_1.JS.Kind.ExportSpecifier) {
-                return this.abort(exportSpecifier);
-            }
-            const otherExportSpecifier = other;
-            // Compare typeOnly
-            if (exportSpecifier.typeOnly.element !== otherExportSpecifier.typeOnly.element) {
-                return this.abort(exportSpecifier);
-            }
-            // Visit specifier
-            yield this.visit(exportSpecifier.specifier, otherExportSpecifier.specifier);
-            if (!this.match)
-                return exportSpecifier;
-            return exportSpecifier;
+            return this.visitElement(exportSpecifier, other);
         });
     }
     /**
@@ -4309,70 +1913,7 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      */
     visitComputedPropertyMethodDeclaration(computedPropMethod, other) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match || other.kind !== tree_1.JS.Kind.ComputedPropertyMethodDeclaration) {
-                return this.abort(computedPropMethod);
-            }
-            const otherComputedPropMethod = other;
-            // 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++) {
-                yield 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++) {
-                yield 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) {
-                yield 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) {
-                yield this.visit(computedPropMethod.returnTypeExpression, otherComputedPropMethod.returnTypeExpression);
-                if (!this.match)
-                    return computedPropMethod;
-            }
-            // Visit name
-            yield 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++) {
-                yield 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) {
-                yield this.visit(computedPropMethod.body, otherComputedPropMethod.body);
-            }
-            return computedPropMethod;
+            return this.visitElement(computedPropMethod, other);
         });
     }
 }
@@ -4384,13 +1925,52 @@ exports.JavaScriptComparatorVisitor = JavaScriptComparatorVisitor;
  * when both refer to the same method).
  */
 class JavaScriptSemanticComparatorVisitor extends JavaScriptComparatorVisitor {
+    /**
+     * Creates a new semantic comparator visitor.
+     *
+     * @param lenientTypeMatching If true, allows matching between nodes with and without type annotations
+     */
+    constructor(lenientTypeMatching = 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).
+     */
+    visitProperty(j, other) {
+        const _super = Object.create(null, {
+            visitProperty: { get: () => super.visitProperty }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            // 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 === null || j === void 0 ? void 0 : j.kind;
+                    const otherKind = other === null || other === void 0 ? void 0 : other.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.call(this, 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.
      */
     isOfType(target, source) {
         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) {
             return false;
@@ -4468,7 +2048,11 @@ class JavaScriptSemanticComparatorVisitor extends JavaScriptComparatorVisitor {
             // 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.call(this, method, other);
+                }
+                // Strict mode: if one has type but the other doesn't, they don't match
                 if (method.methodType || otherMethod.methodType) {
                     return this.abort(method);
                 }
@@ -4496,9 +2080,6 @@ class JavaScriptSemanticComparatorVisitor extends JavaScriptComparatorVisitor {
                 }
                 if (method.select && otherMethod.select) {
                     yield this.visit(method.select.element, otherMethod.select.element);
-                    if (!this.match) {
-                        return this.abort(method);
-                    }
                 }
             }
             // Compare type parameters
@@ -4554,12 +2135,160 @@ class JavaScriptSemanticComparatorVisitor extends JavaScriptComparatorVisitor {
                 }
             }
             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.call(this, identifier, other);
         });
     }
+    /**
+     * Override variable declarations comparison to handle lenient type matching.
+     * When lenientTypeMatching is true, patterns without typeExpression can match
+     * code with typeExpression.
+     */
+    visitVariableDeclarations(variableDeclarations, other) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const otherVariableDeclarations = other;
+            // Visit leading annotations
+            if (variableDeclarations.leadingAnnotations.length !== otherVariableDeclarations.leadingAnnotations.length) {
+                return this.abort(variableDeclarations);
+            }
+            for (let i = 0; i < variableDeclarations.leadingAnnotations.length; i++) {
+                yield this.visit(variableDeclarations.leadingAnnotations[i], otherVariableDeclarations.leadingAnnotations[i]);
+                if (!this.match)
+                    return variableDeclarations;
+            }
+            // Visit modifiers
+            if (variableDeclarations.modifiers.length !== otherVariableDeclarations.modifiers.length) {
+                return this.abort(variableDeclarations);
+            }
+            for (let i = 0; i < variableDeclarations.modifiers.length; i++) {
+                yield this.visit(variableDeclarations.modifiers[i], otherVariableDeclarations.modifiers[i]);
+                if (!this.match)
+                    return variableDeclarations;
+            }
+            // 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
+                yield 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++) {
+                yield 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.
+     */
+    visitMethodDeclaration(methodDeclaration, other) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const otherMethodDeclaration = other;
+            // Visit leading annotations
+            if (methodDeclaration.leadingAnnotations.length !== otherMethodDeclaration.leadingAnnotations.length) {
+                return this.abort(methodDeclaration);
+            }
+            for (let i = 0; i < methodDeclaration.leadingAnnotations.length; i++) {
+                yield this.visit(methodDeclaration.leadingAnnotations[i], otherMethodDeclaration.leadingAnnotations[i]);
+                if (!this.match)
+                    return methodDeclaration;
+            }
+            // Visit modifiers
+            if (methodDeclaration.modifiers.length !== otherMethodDeclaration.modifiers.length) {
+                return this.abort(methodDeclaration);
+            }
+            for (let i = 0; i < methodDeclaration.modifiers.length; i++) {
+                yield this.visit(methodDeclaration.modifiers[i], otherMethodDeclaration.modifiers[i]);
+                if (!this.match)
+                    return methodDeclaration;
+            }
+            // Visit type parameters if present
+            if (!!methodDeclaration.typeParameters !== !!otherMethodDeclaration.typeParameters) {
+                return this.abort(methodDeclaration);
+            }
+            if (methodDeclaration.typeParameters && otherMethodDeclaration.typeParameters) {
+                yield 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
+                yield this.visit(methodDeclaration.returnTypeExpression, otherMethodDeclaration.returnTypeExpression);
+                if (!this.match)
+                    return methodDeclaration;
+            }
+            // Visit name
+            yield 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++) {
+                yield 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++) {
+                    yield 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) {
+                yield this.visit(methodDeclaration.body, otherMethodDeclaration.body);
+                if (!this.match)
+                    return methodDeclaration;
+            }
+            return methodDeclaration;
+        });
+    }
 }
 exports.JavaScriptSemanticComparatorVisitor = JavaScriptSemanticComparatorVisitor;
 //# sourceMappingURL=comparator.js.map