@openrewrite/rewrite 8.72.2 → 8.72.4

package/dist/javascript/templating/comparator.js

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DebugPatternMatchingComparator = exports.PatternMatchingComparator = void 0;
 /*
@@ -73,51 +64,46 @@ class PatternMatchingComparator extends comparator_1.JavaScriptSemanticComparato
             captures: new CaptureMapImpl(state.storage)
         };
     }
-    visit(j, p, parent) {
-        const _super = Object.create(null, {
-            visit: { get: () => super.visit }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            // Check if the pattern node is a capture - this handles unwrapped captures
-            // (Wrapped captures in J.RightPadded are handled by visitRightPadded override)
-            // Note: targetCursor will be pushed by parent's visit() method after this check
-            const captureMarker = utils_1.PlaceholderUtils.getCaptureMarker(j);
-            if (captureMarker) {
-                // Push targetCursor to position it at the captured node for constraint evaluation
-                // Only create cursor if targetCursor was initialized (meaning user provided one)
-                const savedTargetCursor = this.targetCursor;
-                const cursorAtCapturedNode = this.targetCursor !== undefined
-                    ? new __1.Cursor(p, this.targetCursor)
-                    : new __1.Cursor(p);
-                this.targetCursor = cursorAtCapturedNode;
-                try {
-                    // Evaluate constraint with context (cursor + previous captures)
-                    // Skip constraint for variadic captures - they're evaluated in matchSequence with the full array
-                    if (captureMarker.constraint && !captureMarker.variadicOptions) {
-                        const context = this.buildConstraintContext(cursorAtCapturedNode);
-                        if (!captureMarker.constraint(p, context)) {
-                            const captureName = captureMarker.captureName || 'unnamed';
-                            const targetKind = p.kind || 'unknown';
-                            return this.constraintFailed(captureName, targetKind);
-                        }
-                    }
-                    const success = this.matcher.handleCapture(captureMarker, p, undefined);
-                    if (!success) {
+    async visit(j, p, parent) {
+        // Check if the pattern node is a capture - this handles unwrapped captures
+        // (Wrapped captures in J.RightPadded are handled by visitRightPadded override)
+        // Note: targetCursor will be pushed by parent's visit() method after this check
+        const captureMarker = utils_1.PlaceholderUtils.getCaptureMarker(j);
+        if (captureMarker) {
+            // Push targetCursor to position it at the captured node for constraint evaluation
+            // Only create cursor if targetCursor was initialized (meaning user provided one)
+            const savedTargetCursor = this.targetCursor;
+            const cursorAtCapturedNode = this.targetCursor !== undefined
+                ? new __1.Cursor(p, this.targetCursor)
+                : new __1.Cursor(p);
+            this.targetCursor = cursorAtCapturedNode;
+            try {
+                // Evaluate constraint with context (cursor + previous captures)
+                // Skip constraint for variadic captures - they're evaluated in matchSequence with the full array
+                if (captureMarker.constraint && !captureMarker.variadicOptions) {
+                    const context = this.buildConstraintContext(cursorAtCapturedNode);
+                    if (!captureMarker.constraint(p, context)) {
                         const captureName = captureMarker.captureName || 'unnamed';
-                        return this.captureConflict(captureName);
+                        const targetKind = p.kind || 'unknown';
+                        return this.constraintFailed(captureName, targetKind);
                     }
-                    return j;
                 }
-                finally {
-                    this.targetCursor = savedTargetCursor;
+                const success = this.matcher.handleCapture(captureMarker, p, undefined);
+                if (!success) {
+                    const captureName = captureMarker.captureName || 'unnamed';
+                    return this.captureConflict(captureName);
                 }
-            }
-            if (!this.match) {
                 return j;
             }
-            // Continue with parent's visit which will push targetCursor and traverse
-            return yield _super.visit.call(this, j, p, parent);
-        });
+            finally {
+                this.targetCursor = savedTargetCursor;
+            }
+        }
+        if (!this.match) {
+            return j;
+        }
+        // Continue with parent's visit which will push targetCursor and traverse
+        return await super.visit(j, p, parent);
     }
     hasSameKind(j, other) {
         return super.hasSameKind(j, other) ||
@@ -140,102 +126,92 @@ class PatternMatchingComparator extends comparator_1.JavaScriptSemanticComparato
      * Override visitRightPadded to check if this wrapper has a CaptureMarker.
      * If so, capture the entire wrapper (to preserve markers like semicolons).
      */
-    visitRightPadded(right, p) {
-        const _super = Object.create(null, {
-            visitRightPadded: { get: () => super.visitRightPadded }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match) {
-                return right;
-            }
-            // Check if this RightPadded has a CaptureMarker (attached during pattern construction)
-            // Note: Markers are now only at the wrapper level, not at the element level
-            const captureMarker = utils_1.PlaceholderUtils.getCaptureMarker(right);
-            if (captureMarker) {
-                // Extract the target wrapper if it's also a RightPadded
-                const isRightPadded = p.kind === java_1.J.Kind.RightPadded;
-                const targetWrapper = isRightPadded ? p : undefined;
-                const targetElement = isRightPadded ? targetWrapper.element : p;
-                // Push targetCursor to position it at the captured element for constraint evaluation
-                const savedTargetCursor = this.targetCursor;
-                const cursorAtCapturedNode = this.targetCursor !== undefined
-                    ? (targetWrapper ? new __1.Cursor(targetWrapper, this.targetCursor) : new __1.Cursor(targetElement, this.targetCursor))
-                    : (targetWrapper ? new __1.Cursor(targetWrapper) : new __1.Cursor(targetElement));
-                this.targetCursor = cursorAtCapturedNode;
-                try {
-                    // Evaluate constraint with cursor at the captured node (always defined)
-                    // Skip constraint for variadic captures - they're evaluated in matchSequence with the full array
-                    if (captureMarker.constraint && !captureMarker.variadicOptions && !captureMarker.constraint(targetElement, this.buildConstraintContext(cursorAtCapturedNode))) {
-                        const captureName = captureMarker.captureName || 'unnamed';
-                        const targetKind = targetElement.kind || 'unknown';
-                        return this.constraintFailed(captureName, targetKind);
-                    }
-                    // Handle the capture with the wrapper - use the element for pattern matching
-                    const success = this.matcher.handleCapture(captureMarker, targetElement, targetWrapper);
-                    if (!success) {
-                        const captureName = captureMarker.captureName || 'unnamed';
-                        return this.captureConflict(captureName);
-                    }
-                    return right;
+    async visitRightPadded(right, p) {
+        if (!this.match) {
+            return right;
+        }
+        // Check if this RightPadded has a CaptureMarker (attached during pattern construction)
+        // Note: Markers are now only at the wrapper level, not at the element level
+        const captureMarker = utils_1.PlaceholderUtils.getCaptureMarker(right);
+        if (captureMarker) {
+            // Extract the target wrapper if it's also a RightPadded
+            const isRightPadded = p.kind === java_1.J.Kind.RightPadded;
+            const targetWrapper = isRightPadded ? p : undefined;
+            const targetElement = isRightPadded ? targetWrapper.element : p;
+            // Push targetCursor to position it at the captured element for constraint evaluation
+            const savedTargetCursor = this.targetCursor;
+            const cursorAtCapturedNode = this.targetCursor !== undefined
+                ? (targetWrapper ? new __1.Cursor(targetWrapper, this.targetCursor) : new __1.Cursor(targetElement, this.targetCursor))
+                : (targetWrapper ? new __1.Cursor(targetWrapper) : new __1.Cursor(targetElement));
+            this.targetCursor = cursorAtCapturedNode;
+            try {
+                // Evaluate constraint with cursor at the captured node (always defined)
+                // Skip constraint for variadic captures - they're evaluated in matchSequence with the full array
+                if (captureMarker.constraint && !captureMarker.variadicOptions && !captureMarker.constraint(targetElement, this.buildConstraintContext(cursorAtCapturedNode))) {
+                    const captureName = captureMarker.captureName || 'unnamed';
+                    const targetKind = targetElement.kind || 'unknown';
+                    return this.constraintFailed(captureName, targetKind);
                 }
-                finally {
-                    this.targetCursor = savedTargetCursor;
+                // Handle the capture with the wrapper - use the element for pattern matching
+                const success = this.matcher.handleCapture(captureMarker, targetElement, targetWrapper);
+                if (!success) {
+                    const captureName = captureMarker.captureName || 'unnamed';
+                    return this.captureConflict(captureName);
                 }
+                return right;
             }
-            // Not a capture wrapper - use parent implementation
-            return _super.visitRightPadded.call(this, right, p);
-        });
-    }
-    visitContainer(container, p) {
-        const _super = Object.create(null, {
-            visitContainer: { get: () => super.visitContainer }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            // Check if any elements are variadic captures
-            const hasVariadicCapture = container.elements.some(elem => utils_1.PlaceholderUtils.isVariadicCapture(elem));
-            // If no variadic captures, use parent implementation
-            if (!hasVariadicCapture) {
-                return _super.visitContainer.call(this, container, p);
-            }
-            // Otherwise, handle variadic captures ourselves
-            if (!this.match) {
-                return container;
-            }
-            // Extract the other container
-            const isContainer = p.kind === java_1.J.Kind.Container;
-            if (!isContainer) {
-                // Set up cursors temporarily for kindMismatch to use
-                const savedCursor = this.cursor;
-                const savedTargetCursor = this.targetCursor;
-                this.cursor = new __1.Cursor(container, this.cursor);
-                this.targetCursor = new __1.Cursor(p, this.targetCursor);
-                try {
-                    return this.kindMismatch();
-                }
-                finally {
-                    this.cursor = savedCursor;
-                    this.targetCursor = savedTargetCursor;
-                }
+            finally {
+                this.targetCursor = savedTargetCursor;
             }
-            const otherContainer = p;
-            // Push wrappers onto both cursors
+        }
+        // Not a capture wrapper - use parent implementation
+        return super.visitRightPadded(right, p);
+    }
+    async visitContainer(container, p) {
+        // Check if any elements are variadic captures
+        const hasVariadicCapture = container.elements.some(elem => utils_1.PlaceholderUtils.isVariadicCapture(elem));
+        // If no variadic captures, use parent implementation
+        if (!hasVariadicCapture) {
+            return super.visitContainer(container, p);
+        }
+        // Otherwise, handle variadic captures ourselves
+        if (!this.match) {
+            return container;
+        }
+        // Extract the other container
+        const isContainer = p.kind === java_1.J.Kind.Container;
+        if (!isContainer) {
+            // Set up cursors temporarily for kindMismatch to use
             const savedCursor = this.cursor;
             const savedTargetCursor = this.targetCursor;
             this.cursor = new __1.Cursor(container, this.cursor);
-            this.targetCursor = new __1.Cursor(otherContainer, this.targetCursor);
+            this.targetCursor = new __1.Cursor(p, this.targetCursor);
             try {
-                // Use matchSequence for variadic matching
-                // filterEmpty=true to skip J.Empty elements (they represent missing elements in destructuring)
-                if (!(yield this.matchSequence(container.elements, otherContainer.elements, true))) {
-                    return this.structuralMismatch('elements');
-                }
+                return this.kindMismatch();
             }
             finally {
                 this.cursor = savedCursor;
                 this.targetCursor = savedTargetCursor;
             }
-            return container;
-        });
+        }
+        const otherContainer = p;
+        // Push wrappers onto both cursors
+        const savedCursor = this.cursor;
+        const savedTargetCursor = this.targetCursor;
+        this.cursor = new __1.Cursor(container, this.cursor);
+        this.targetCursor = new __1.Cursor(otherContainer, this.targetCursor);
+        try {
+            // Use matchSequence for variadic matching
+            // filterEmpty=true to skip J.Empty elements (they represent missing elements in destructuring)
+            if (!await this.matchSequence(container.elements, otherContainer.elements, true)) {
+                return this.structuralMismatch('elements');
+            }
+        }
+        finally {
+            this.cursor = savedCursor;
+            this.targetCursor = savedTargetCursor;
+        }
+        return container;
     }
     /**
      * Visit a single element in a container (for non-variadic matching).
@@ -246,200 +222,181 @@ class PatternMatchingComparator extends comparator_1.JavaScriptSemanticComparato
      * @param index The index in the container
      * @returns true if matching should continue, false if it failed
      */
-    visitContainerElement(element, otherElement, index) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.visitRightPadded(element, otherElement);
-            return this.match;
-        });
+    async visitContainerElement(element, otherElement, index) {
+        await this.visitRightPadded(element, otherElement);
+        return this.match;
     }
-    visitMethodInvocation(methodInvocation, other) {
-        const _super = Object.create(null, {
-            visitMethodInvocation: { get: () => super.visitMethodInvocation }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            // Check if any arguments are variadic captures
-            const hasVariadicCapture = methodInvocation.arguments.elements.some(arg => utils_1.PlaceholderUtils.isVariadicCapture(arg));
-            // If no variadic captures, use parent implementation (which includes semantic/type-aware matching)
-            if (!hasVariadicCapture) {
-                return _super.visitMethodInvocation.call(this, methodInvocation, other);
-            }
-            // Otherwise, handle variadic captures ourselves
-            if (!this.match) {
-                return this.abort(methodInvocation);
-            }
-            if (other.kind !== java_1.J.Kind.MethodInvocation) {
-                // Set up cursors for kindMismatch
-                const savedCursor = this.cursor;
-                const savedTargetCursor = this.targetCursor;
-                this.cursor = new __1.Cursor(methodInvocation, this.cursor);
-                this.targetCursor = new __1.Cursor(other, this.targetCursor);
-                try {
-                    return this.kindMismatch();
-                }
-                finally {
-                    this.cursor = savedCursor;
-                    this.targetCursor = savedTargetCursor;
-                }
-            }
-            const otherMethodInvocation = other;
-            // Set up cursors for the entire method
+    async visitMethodInvocation(methodInvocation, other) {
+        // Check if any arguments are variadic captures
+        const hasVariadicCapture = methodInvocation.arguments.elements.some(arg => utils_1.PlaceholderUtils.isVariadicCapture(arg));
+        // If no variadic captures, use parent implementation (which includes semantic/type-aware matching)
+        if (!hasVariadicCapture) {
+            return super.visitMethodInvocation(methodInvocation, other);
+        }
+        // Otherwise, handle variadic captures ourselves
+        if (!this.match) {
+            return this.abort(methodInvocation);
+        }
+        if (other.kind !== java_1.J.Kind.MethodInvocation) {
+            // Set up cursors for kindMismatch
             const savedCursor = this.cursor;
             const savedTargetCursor = this.targetCursor;
             this.cursor = new __1.Cursor(methodInvocation, this.cursor);
-            this.targetCursor = new __1.Cursor(otherMethodInvocation, this.targetCursor);
+            this.targetCursor = new __1.Cursor(other, this.targetCursor);
             try {
-                // Compare select
-                if ((methodInvocation.select === undefined) !== (otherMethodInvocation.select === undefined)) {
-                    return this.structuralMismatch('select');
-                }
-                // 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.structuralMismatch('typeParameters');
-                }
-                // Visit typeParameters if present
-                if (methodInvocation.typeParameters && otherMethodInvocation.typeParameters) {
-                    if (methodInvocation.typeParameters.elements.length !== otherMethodInvocation.typeParameters.elements.length) {
-                        return this.arrayLengthMismatch('typeParameters.elements');
-                    }
-                    // Visit each type parameter in lock step (visit RightPadded to check for markers)
-                    for (let i = 0; i < methodInvocation.typeParameters.elements.length; i++) {
-                        yield this.visitRightPadded(methodInvocation.typeParameters.elements[i], otherMethodInvocation.typeParameters.elements[i]);
-                        if (!this.match)
-                            return methodInvocation;
-                    }
-                }
-                // Visit name
-                yield this.visit(methodInvocation.name, otherMethodInvocation.name);
-                if (!this.match) {
-                    return methodInvocation;
-                }
-                // Special handling for variadic captures in arguments
-                if (!(yield this.matchArguments(methodInvocation.arguments.elements, otherMethodInvocation.arguments.elements))) {
-                    return this.structuralMismatch('arguments');
-                }
-                return methodInvocation;
+                return this.kindMismatch();
             }
             finally {
                 this.cursor = savedCursor;
                 this.targetCursor = savedTargetCursor;
             }
-        });
-    }
-    visitBlock(block, other) {
-        const _super = Object.create(null, {
-            visitBlock: { get: () => super.visitBlock }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            // Check if any statements have CaptureMarker indicating they're variadic
-            const hasVariadicCapture = block.statements.some(stmt => {
-                const captureMarker = utils_1.PlaceholderUtils.getCaptureMarker(stmt);
-                return (captureMarker === null || captureMarker === void 0 ? void 0 : captureMarker.variadicOptions) !== undefined;
-            });
-            // If no variadic captures, use parent implementation
-            if (!hasVariadicCapture) {
-                return _super.visitBlock.call(this, block, other);
+        }
+        const otherMethodInvocation = other;
+        // Set up cursors for the entire method
+        const savedCursor = this.cursor;
+        const savedTargetCursor = this.targetCursor;
+        this.cursor = new __1.Cursor(methodInvocation, this.cursor);
+        this.targetCursor = new __1.Cursor(otherMethodInvocation, this.targetCursor);
+        try {
+            // Compare select
+            if ((methodInvocation.select === undefined) !== (otherMethodInvocation.select === undefined)) {
+                return this.structuralMismatch('select');
             }
-            // Otherwise, handle variadic captures ourselves
-            if (!this.match) {
-                return this.abort(block);
+            // Visit select if present
+            if (methodInvocation.select && otherMethodInvocation.select) {
+                await this.visit(methodInvocation.select.element, otherMethodInvocation.select.element);
+                if (!this.match)
+                    return methodInvocation;
             }
-            if (other.kind !== java_1.J.Kind.Block) {
-                // Set up cursors for kindMismatch
-                const savedCursor = this.cursor;
-                const savedTargetCursor = this.targetCursor;
-                this.cursor = new __1.Cursor(block, this.cursor);
-                this.targetCursor = new __1.Cursor(other, this.targetCursor);
-                try {
-                    return this.kindMismatch();
+            // Compare typeParameters
+            if ((methodInvocation.typeParameters === undefined) !== (otherMethodInvocation.typeParameters === undefined)) {
+                return this.structuralMismatch('typeParameters');
+            }
+            // Visit typeParameters if present
+            if (methodInvocation.typeParameters && otherMethodInvocation.typeParameters) {
+                if (methodInvocation.typeParameters.elements.length !== otherMethodInvocation.typeParameters.elements.length) {
+                    return this.arrayLengthMismatch('typeParameters.elements');
                 }
-                finally {
-                    this.cursor = savedCursor;
-                    this.targetCursor = savedTargetCursor;
+                // Visit each type parameter in lock step (visit RightPadded to check for markers)
+                for (let i = 0; i < methodInvocation.typeParameters.elements.length; i++) {
+                    await this.visitRightPadded(methodInvocation.typeParameters.elements[i], otherMethodInvocation.typeParameters.elements[i]);
+                    if (!this.match)
+                        return methodInvocation;
                 }
             }
-            const otherBlock = other;
-            // Set up cursors for structural comparison
+            // Visit name
+            await this.visit(methodInvocation.name, otherMethodInvocation.name);
+            if (!this.match) {
+                return methodInvocation;
+            }
+            // Special handling for variadic captures in arguments
+            if (!await this.matchArguments(methodInvocation.arguments.elements, otherMethodInvocation.arguments.elements)) {
+                return this.structuralMismatch('arguments');
+            }
+            return methodInvocation;
+        }
+        finally {
+            this.cursor = savedCursor;
+            this.targetCursor = savedTargetCursor;
+        }
+    }
+    async visitBlock(block, other) {
+        // Check if any statements have CaptureMarker indicating they're variadic
+        const hasVariadicCapture = block.statements.some(stmt => {
+            const captureMarker = utils_1.PlaceholderUtils.getCaptureMarker(stmt);
+            return (captureMarker === null || captureMarker === void 0 ? void 0 : captureMarker.variadicOptions) !== undefined;
+        });
+        // If no variadic captures, use parent implementation
+        if (!hasVariadicCapture) {
+            return super.visitBlock(block, other);
+        }
+        // Otherwise, handle variadic captures ourselves
+        if (!this.match) {
+            return this.abort(block);
+        }
+        if (other.kind !== java_1.J.Kind.Block) {
+            // Set up cursors for kindMismatch
             const savedCursor = this.cursor;
             const savedTargetCursor = this.targetCursor;
             this.cursor = new __1.Cursor(block, this.cursor);
-            this.targetCursor = new __1.Cursor(otherBlock, this.targetCursor);
+            this.targetCursor = new __1.Cursor(other, this.targetCursor);
             try {
-                // Special handling for variadic captures in statements
-                if (!(yield this.matchSequence(block.statements, otherBlock.statements, false))) {
-                    return this.structuralMismatch('statements');
-                }
-                return block;
+                return this.kindMismatch();
             }
             finally {
                 this.cursor = savedCursor;
                 this.targetCursor = savedTargetCursor;
             }
-        });
+        }
+        const otherBlock = other;
+        // Set up cursors for structural comparison
+        const savedCursor = this.cursor;
+        const savedTargetCursor = this.targetCursor;
+        this.cursor = new __1.Cursor(block, this.cursor);
+        this.targetCursor = new __1.Cursor(otherBlock, this.targetCursor);
+        try {
+            // Special handling for variadic captures in statements
+            if (!await this.matchSequence(block.statements, otherBlock.statements, false)) {
+                return this.structuralMismatch('statements');
+            }
+            return block;
+        }
+        finally {
+            this.cursor = savedCursor;
+            this.targetCursor = savedTargetCursor;
+        }
     }
-    visitJsCompilationUnit(compilationUnit, other) {
-        const _super = Object.create(null, {
-            visitJsCompilationUnit: { get: () => super.visitJsCompilationUnit }
+    async visitJsCompilationUnit(compilationUnit, other) {
+        // Check if any statements are variadic captures
+        const hasVariadicCapture = compilationUnit.statements.some(stmt => {
+            return utils_1.PlaceholderUtils.isVariadicCapture(stmt);
         });
-        return __awaiter(this, void 0, void 0, function* () {
-            // Check if any statements are variadic captures
-            const hasVariadicCapture = compilationUnit.statements.some(stmt => {
-                return utils_1.PlaceholderUtils.isVariadicCapture(stmt);
-            });
-            // If no variadic captures, use parent implementation
-            if (!hasVariadicCapture) {
-                return _super.visitJsCompilationUnit.call(this, compilationUnit, other);
-            }
-            // Otherwise, handle variadic captures ourselves
-            if (!this.match) {
-                return this.abort(compilationUnit);
-            }
-            if (other.kind !== index_1.JS.Kind.CompilationUnit) {
-                // Set up cursors for kindMismatch
-                const savedCursor = this.cursor;
-                const savedTargetCursor = this.targetCursor;
-                this.cursor = new __1.Cursor(compilationUnit, this.cursor);
-                this.targetCursor = new __1.Cursor(other, this.targetCursor);
-                try {
-                    return this.kindMismatch();
-                }
-                finally {
-                    this.cursor = savedCursor;
-                    this.targetCursor = savedTargetCursor;
-                }
-            }
-            const otherCompilationUnit = other;
-            // Set up cursors for structural comparison
+        // If no variadic captures, use parent implementation
+        if (!hasVariadicCapture) {
+            return super.visitJsCompilationUnit(compilationUnit, other);
+        }
+        // Otherwise, handle variadic captures ourselves
+        if (!this.match) {
+            return this.abort(compilationUnit);
+        }
+        if (other.kind !== index_1.JS.Kind.CompilationUnit) {
+            // Set up cursors for kindMismatch
             const savedCursor = this.cursor;
             const savedTargetCursor = this.targetCursor;
             this.cursor = new __1.Cursor(compilationUnit, this.cursor);
-            this.targetCursor = new __1.Cursor(otherCompilationUnit, this.targetCursor);
+            this.targetCursor = new __1.Cursor(other, this.targetCursor);
             try {
-                // Special handling for variadic captures in top-level statements
-                if (!(yield this.matchSequence(compilationUnit.statements, otherCompilationUnit.statements, false))) {
-                    return this.structuralMismatch('statements');
-                }
-                return compilationUnit;
+                return this.kindMismatch();
             }
             finally {
                 this.cursor = savedCursor;
                 this.targetCursor = savedTargetCursor;
             }
-        });
+        }
+        const otherCompilationUnit = other;
+        // Set up cursors for structural comparison
+        const savedCursor = this.cursor;
+        const savedTargetCursor = this.targetCursor;
+        this.cursor = new __1.Cursor(compilationUnit, this.cursor);
+        this.targetCursor = new __1.Cursor(otherCompilationUnit, this.targetCursor);
+        try {
+            // Special handling for variadic captures in top-level statements
+            if (!await this.matchSequence(compilationUnit.statements, otherCompilationUnit.statements, false)) {
+                return this.structuralMismatch('statements');
+            }
+            return compilationUnit;
+        }
+        finally {
+            this.cursor = savedCursor;
+            this.targetCursor = savedTargetCursor;
+        }
     }
     /**
      * Matches argument lists, with special handling for variadic captures.
      * A variadic capture can match zero or more consecutive arguments.
      */
-    matchArguments(patternArgs, targetArgs) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return yield this.matchSequence(patternArgs, targetArgs, true);
-        });
+    async matchArguments(patternArgs, targetArgs) {
+        return await this.matchSequence(patternArgs, targetArgs, true);
     }
     /**
      * Generic sequence matching with variadic capture support.
@@ -453,10 +410,8 @@ class PatternMatchingComparator extends comparator_1.JavaScriptSemanticComparato
      * @param filterEmpty Whether to filter out J.Empty elements when capturing (true for arguments, false for statements)
      * @returns true if the sequence matches, false otherwise
      */
-    matchSequence(patternElements, targetElements, filterEmpty) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return yield this.matchSequenceOptimized(patternElements, targetElements, 0, 0, filterEmpty);
-        });
+    async matchSequence(patternElements, targetElements, filterEmpty) {
+        return await this.matchSequenceOptimized(patternElements, targetElements, 0, 0, filterEmpty);
     }
     /**
      * Optimized sequence matcher with pivot detection and backtracking.
@@ -470,154 +425,152 @@ class PatternMatchingComparator extends comparator_1.JavaScriptSemanticComparato
      * @param filterEmpty Whether to filter out J.Empty elements when capturing
      * @returns true if the remaining sequence matches, false otherwise
      */
-    matchSequenceOptimized(patternElements, targetElements, patternIdx, targetIdx, filterEmpty) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b;
-            // Base case: all patterns matched
-            if (patternIdx >= patternElements.length) {
-                return targetIdx >= targetElements.length; // Success if all targets consumed
-            }
-            // Check for markers at wrapper level only (markers are now only at the outermost level)
-            const patternWrapper = patternElements[patternIdx];
-            const captureMarker = utils_1.PlaceholderUtils.getCaptureMarker(patternWrapper);
-            const isVariadic = (captureMarker === null || captureMarker === void 0 ? void 0 : captureMarker.variadicOptions) !== undefined;
-            if (isVariadic) {
-                // Variadic pattern: try different consumption amounts with backtracking
-                const variadicOptions = captureMarker.variadicOptions;
-                const min = (_a = variadicOptions === null || variadicOptions === void 0 ? void 0 : variadicOptions.min) !== null && _a !== void 0 ? _a : 0;
-                const max = (_b = variadicOptions === null || variadicOptions === void 0 ? void 0 : variadicOptions.max) !== null && _b !== void 0 ? _b : Infinity;
-                // Calculate maximum possible consumption and check if remaining patterns are deterministic
-                let nonVariadicRemainingPatterns = 0;
-                let allRemainingPatternsAreDeterministic = true;
-                for (let i = patternIdx + 1; i < patternElements.length; i++) {
-                    const nextCaptureMarker = utils_1.PlaceholderUtils.getCaptureMarker(patternElements[i]);
-                    const nextIsVariadic = (nextCaptureMarker === null || nextCaptureMarker === void 0 ? void 0 : nextCaptureMarker.variadicOptions) !== undefined;
-                    if (!nextIsVariadic) {
-                        nonVariadicRemainingPatterns++;
-                    }
-                    // A pattern is deterministic if it's not a capture at all (i.e., a literal/fixed structure)
-                    // Variadic captures and non-variadic captures are both non-deterministic
-                    if (nextCaptureMarker) {
-                        allRemainingPatternsAreDeterministic = false;
-                    }
-                }
-                const remainingTargetElements = targetElements.length - targetIdx;
-                const maxPossible = Math.min(remainingTargetElements - nonVariadicRemainingPatterns, max);
-                // Pivot detection optimization: try to find where next pattern matches
-                // This avoids unnecessary backtracking when constraints make the split point obvious
-                let pivotDetected = false;
-                let pivotAt = -1;
-                // Skip pivot detection if we're using deterministic optimization
-                // (when all remaining patterns are literals, there's only ONE valid consumption amount)
-                const useDeterministicOptimization = allRemainingPatternsAreDeterministic && maxPossible >= min && maxPossible <= max;
-                if (!useDeterministicOptimization && patternIdx + 1 < patternElements.length && min <= maxPossible) {
-                    const nextPattern = patternElements[patternIdx + 1];
-                    // Scan through possible consumption amounts starting from min
-                    for (let tryConsume = min; tryConsume <= maxPossible; tryConsume++) {
-                        // Check if element after our consumption would match next pattern
-                        if (targetIdx + tryConsume < targetElements.length) {
-                            const candidateElement = targetElements[targetIdx + tryConsume];
-                            // Skip J.Empty for arguments
-                            if (filterEmpty && candidateElement.element.kind === java_1.J.Kind.Empty) {
-                                continue;
-                            }
-                            // Test if next pattern matches this element
-                            const savedMatch = this.match;
-                            const savedState = this.matcher.saveState();
-                            yield this.visitRightPadded(nextPattern, candidateElement);
-                            const matchesNext = this.match;
-                            this.match = savedMatch;
-                            this.matcher.restoreState(savedState);
-                            if (matchesNext) {
-                                // Found pivot! Try this consumption amount first
-                                pivotDetected = true;
-                                pivotAt = tryConsume;
-                                break;
-                            }
-                        }
-                    }
+    async matchSequenceOptimized(patternElements, targetElements, patternIdx, targetIdx, filterEmpty) {
+        var _a, _b;
+        // Base case: all patterns matched
+        if (patternIdx >= patternElements.length) {
+            return targetIdx >= targetElements.length; // Success if all targets consumed
+        }
+        // Check for markers at wrapper level only (markers are now only at the outermost level)
+        const patternWrapper = patternElements[patternIdx];
+        const captureMarker = utils_1.PlaceholderUtils.getCaptureMarker(patternWrapper);
+        const isVariadic = (captureMarker === null || captureMarker === void 0 ? void 0 : captureMarker.variadicOptions) !== undefined;
+        if (isVariadic) {
+            // Variadic pattern: try different consumption amounts with backtracking
+            const variadicOptions = captureMarker.variadicOptions;
+            const min = (_a = variadicOptions === null || variadicOptions === void 0 ? void 0 : variadicOptions.min) !== null && _a !== void 0 ? _a : 0;
+            const max = (_b = variadicOptions === null || variadicOptions === void 0 ? void 0 : variadicOptions.max) !== null && _b !== void 0 ? _b : Infinity;
+            // Calculate maximum possible consumption and check if remaining patterns are deterministic
+            let nonVariadicRemainingPatterns = 0;
+            let allRemainingPatternsAreDeterministic = true;
+            for (let i = patternIdx + 1; i < patternElements.length; i++) {
+                const nextCaptureMarker = utils_1.PlaceholderUtils.getCaptureMarker(patternElements[i]);
+                const nextIsVariadic = (nextCaptureMarker === null || nextCaptureMarker === void 0 ? void 0 : nextCaptureMarker.variadicOptions) !== undefined;
+                if (!nextIsVariadic) {
+                    nonVariadicRemainingPatterns++;
                 }
-                // Determine consumption order
-                const consumptionOrder = [];
-                // OPTIMIZATION: If all remaining patterns are deterministic (literals, not captures),
-                // there's only ONE mathematically valid consumption amount. Skip backtracking entirely.
-                // Example: foo(${args}, 999) matching foo(1,2,42) -> args MUST be [1,2], only try consume=2
-                if (useDeterministicOptimization) {
-                    consumptionOrder.push(maxPossible);
+                // A pattern is deterministic if it's not a capture at all (i.e., a literal/fixed structure)
+                // Variadic captures and non-variadic captures are both non-deterministic
+                if (nextCaptureMarker) {
+                    allRemainingPatternsAreDeterministic = false;
                 }
-                else if (pivotDetected && pivotAt >= 0) {
-                    // Try pivot first, then others as fallback
-                    consumptionOrder.push(pivotAt);
-                    for (let c = maxPossible; c >= min; c--) {
-                        if (c !== pivotAt) {
-                            consumptionOrder.push(c);
+            }
+            const remainingTargetElements = targetElements.length - targetIdx;
+            const maxPossible = Math.min(remainingTargetElements - nonVariadicRemainingPatterns, max);
+            // Pivot detection optimization: try to find where next pattern matches
+            // This avoids unnecessary backtracking when constraints make the split point obvious
+            let pivotDetected = false;
+            let pivotAt = -1;
+            // Skip pivot detection if we're using deterministic optimization
+            // (when all remaining patterns are literals, there's only ONE valid consumption amount)
+            const useDeterministicOptimization = allRemainingPatternsAreDeterministic && maxPossible >= min && maxPossible <= max;
+            if (!useDeterministicOptimization && patternIdx + 1 < patternElements.length && min <= maxPossible) {
+                const nextPattern = patternElements[patternIdx + 1];
+                // Scan through possible consumption amounts starting from min
+                for (let tryConsume = min; tryConsume <= maxPossible; tryConsume++) {
+                    // Check if element after our consumption would match next pattern
+                    if (targetIdx + tryConsume < targetElements.length) {
+                        const candidateElement = targetElements[targetIdx + tryConsume];
+                        // Skip J.Empty for arguments
+                        if (filterEmpty && candidateElement.element.kind === java_1.J.Kind.Empty) {
+                            continue;
+                        }
+                        // Test if next pattern matches this element
+                        const savedMatch = this.match;
+                        const savedState = this.matcher.saveState();
+                        await this.visitRightPadded(nextPattern, candidateElement);
+                        const matchesNext = this.match;
+                        this.match = savedMatch;
+                        this.matcher.restoreState(savedState);
+                        if (matchesNext) {
+                            // Found pivot! Try this consumption amount first
+                            pivotDetected = true;
+                            pivotAt = tryConsume;
+                            break;
                         }
                     }
                 }
-                else {
-                    // Greedy approach: max to min
-                    for (let c = maxPossible; c >= min; c--) {
+            }
+            // Determine consumption order
+            const consumptionOrder = [];
+            // OPTIMIZATION: If all remaining patterns are deterministic (literals, not captures),
+            // there's only ONE mathematically valid consumption amount. Skip backtracking entirely.
+            // Example: foo(${args}, 999) matching foo(1,2,42) -> args MUST be [1,2], only try consume=2
+            if (useDeterministicOptimization) {
+                consumptionOrder.push(maxPossible);
+            }
+            else if (pivotDetected && pivotAt >= 0) {
+                // Try pivot first, then others as fallback
+                consumptionOrder.push(pivotAt);
+                for (let c = maxPossible; c >= min; c--) {
+                    if (c !== pivotAt) {
                         consumptionOrder.push(c);
                     }
                 }
-                for (const consume of consumptionOrder) {
-                    // Capture elements for this consumption amount
-                    // For empty argument lists, there will be a single J.Empty element that we need to filter out
-                    const rawWrappers = targetElements.slice(targetIdx, targetIdx + consume);
-                    const capturedWrappers = filterEmpty
-                        ? rawWrappers.filter(w => w.element.kind !== java_1.J.Kind.Empty)
-                        : rawWrappers;
-                    const capturedElements = capturedWrappers.map(w => w.element);
-                    // Check min/max constraints against filtered elements
-                    if (capturedElements.length < min || capturedElements.length > max) {
-                        continue;
-                    }
-                    // Evaluate constraint for variadic capture
-                    // For variadic captures, constraint receives the entire array of captured elements
-                    // The targetCursor points to the parent container (always defined in container matching)
-                    if (captureMarker.constraint) {
-                        const cursor = this.targetCursor || new __1.Cursor(targetElements[0]);
-                        if (!captureMarker.constraint(capturedElements, this.buildConstraintContext(cursor))) {
-                            continue; // Try next consumption amount
-                        }
-                    }
-                    // Save current state for backtracking
-                    const savedState = this.matcher.saveState();
-                    // Handle the variadic capture
-                    const success = this.matcher.handleVariadicCapture(captureMarker, capturedElements, capturedWrappers);
-                    if (!success) {
-                        // Restore state and try next amount
-                        this.matcher.restoreState(savedState);
-                        continue;
-                    }
-                    // Try to match the rest of the pattern
-                    const restMatches = yield this.matchSequenceOptimized(patternElements, targetElements, patternIdx + 1, targetIdx + consume, filterEmpty);
-                    if (restMatches) {
-                        return true; // Found a valid matching
-                    }
-                    // Backtrack: restore state and try next amount
-                    this.matcher.restoreState(savedState);
-                }
-                return false; // No consumption amount worked
             }
             else {
-                // Regular non-variadic element - must match exactly one target element
-                if (targetIdx >= targetElements.length) {
-                    return false; // Pattern has more elements than target
+                // Greedy approach: max to min
+                for (let c = maxPossible; c >= min; c--) {
+                    consumptionOrder.push(c);
                 }
-                const targetWrapper = targetElements[targetIdx];
-                const targetElement = targetWrapper.element;
-                // For arguments, J.Empty represents no argument, so regular captures should not match it
-                if (filterEmpty && targetElement.kind === java_1.J.Kind.Empty) {
-                    return false;
+            }
+            for (const consume of consumptionOrder) {
+                // Capture elements for this consumption amount
+                // For empty argument lists, there will be a single J.Empty element that we need to filter out
+                const rawWrappers = targetElements.slice(targetIdx, targetIdx + consume);
+                const capturedWrappers = filterEmpty
+                    ? rawWrappers.filter(w => w.element.kind !== java_1.J.Kind.Empty)
+                    : rawWrappers;
+                const capturedElements = capturedWrappers.map(w => w.element);
+                // Check min/max constraints against filtered elements
+                if (capturedElements.length < min || capturedElements.length > max) {
+                    continue;
+                }
+                // Evaluate constraint for variadic capture
+                // For variadic captures, constraint receives the entire array of captured elements
+                // The targetCursor points to the parent container (always defined in container matching)
+                if (captureMarker.constraint) {
+                    const cursor = this.targetCursor || new __1.Cursor(targetElements[0]);
+                    if (!captureMarker.constraint(capturedElements, this.buildConstraintContext(cursor))) {
+                        continue; // Try next consumption amount
+                    }
+                }
+                // Save current state for backtracking
+                const savedState = this.matcher.saveState();
+                // Handle the variadic capture
+                const success = this.matcher.handleVariadicCapture(captureMarker, capturedElements, capturedWrappers);
+                if (!success) {
+                    // Restore state and try next amount
+                    this.matcher.restoreState(savedState);
+                    continue;
                 }
-                if (!(yield this.visitSequenceElement(patternWrapper, targetWrapper, targetIdx))) {
-                    return false;
+                // Try to match the rest of the pattern
+                const restMatches = await this.matchSequenceOptimized(patternElements, targetElements, patternIdx + 1, targetIdx + consume, filterEmpty);
+                if (restMatches) {
+                    return true; // Found a valid matching
                 }
-                // Continue matching the rest
-                return yield this.matchSequenceOptimized(patternElements, targetElements, patternIdx + 1, targetIdx + 1, filterEmpty);
+                // Backtrack: restore state and try next amount
+                this.matcher.restoreState(savedState);
             }
-        });
+            return false; // No consumption amount worked
+        }
+        else {
+            // Regular non-variadic element - must match exactly one target element
+            if (targetIdx >= targetElements.length) {
+                return false; // Pattern has more elements than target
+            }
+            const targetWrapper = targetElements[targetIdx];
+            const targetElement = targetWrapper.element;
+            // For arguments, J.Empty represents no argument, so regular captures should not match it
+            if (filterEmpty && targetElement.kind === java_1.J.Kind.Empty) {
+                return false;
+            }
+            if (!await this.visitSequenceElement(patternWrapper, targetWrapper, targetIdx)) {
+                return false;
+            }
+            // Continue matching the rest
+            return await this.matchSequenceOptimized(patternElements, targetElements, patternIdx + 1, targetIdx + 1, filterEmpty);
+        }
     }
     /**
      * Visit a single element in a sequence during non-variadic matching.
@@ -628,20 +581,18 @@ class PatternMatchingComparator extends comparator_1.JavaScriptSemanticComparato
      * @param targetIdx The index in the target sequence
      * @returns true if matching succeeded, false otherwise
      */
-    visitSequenceElement(patternWrapper, targetWrapper, targetIdx) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // Save current state for backtracking (both match state and capture bindings)
-            const savedMatch = this.match;
-            const savedState = this.matcher.saveState();
-            yield this.visitRightPadded(patternWrapper, targetWrapper);
-            if (!this.match) {
-                // Restore state on match failure
-                this.match = savedMatch;
-                this.matcher.restoreState(savedState);
-                return false;
-            }
-            return true;
-        });
+    async visitSequenceElement(patternWrapper, targetWrapper, targetIdx) {
+        // Save current state for backtracking (both match state and capture bindings)
+        const savedMatch = this.match;
+        const savedState = this.matcher.saveState();
+        await this.visitRightPadded(patternWrapper, targetWrapper);
+        if (!this.match) {
+            // Restore state on match failure
+            this.match = savedMatch;
+            this.matcher.restoreState(savedState);
+            return false;
+        }
+        return true;
     }
 }
 exports.PatternMatchingComparator = PatternMatchingComparator;
@@ -789,467 +740,431 @@ class DebugPatternMatchingComparator extends PatternMatchingComparator {
             }
         }
     }
-    visit(j, p, parent) {
-        const _super = Object.create(null, {
-            visit: { get: () => super.visit }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            const captureMarker = utils_1.PlaceholderUtils.getCaptureMarker(j);
-            if (captureMarker) {
-                const savedTargetCursor = this.targetCursor;
-                const cursorAtCapturedNode = this.targetCursor !== undefined
-                    ? new __1.Cursor(p, this.targetCursor)
-                    : new __1.Cursor(p);
-                this.targetCursor = cursorAtCapturedNode;
-                try {
-                    if (captureMarker.constraint && !captureMarker.variadicOptions) {
-                        this.debug.log('debug', 'constraint', `Evaluating constraint for capture: ${captureMarker.captureName}`);
-                        const constraintResult = captureMarker.constraint(p, this.buildConstraintContext(cursorAtCapturedNode));
-                        if (!constraintResult) {
-                            this.debug.log('info', 'constraint', `Constraint failed for capture: ${captureMarker.captureName}`);
-                            this.debug.setExplanation('constraint-failed', `Capture ${captureMarker.captureName} with valid constraint`, `Constraint failed for ${p.kind}`, `Constraint evaluation returned false`);
-                            return this.abort(j);
-                        }
-                        this.debug.log('debug', 'constraint', `Constraint passed for capture: ${captureMarker.captureName}`);
-                    }
-                    const success = this.matcher.handleCapture(captureMarker, p, undefined);
-                    if (!success) {
+    async visit(j, p, parent) {
+        const captureMarker = utils_1.PlaceholderUtils.getCaptureMarker(j);
+        if (captureMarker) {
+            const savedTargetCursor = this.targetCursor;
+            const cursorAtCapturedNode = this.targetCursor !== undefined
+                ? new __1.Cursor(p, this.targetCursor)
+                : new __1.Cursor(p);
+            this.targetCursor = cursorAtCapturedNode;
+            try {
+                if (captureMarker.constraint && !captureMarker.variadicOptions) {
+                    this.debug.log('debug', 'constraint', `Evaluating constraint for capture: ${captureMarker.captureName}`);
+                    const constraintResult = captureMarker.constraint(p, this.buildConstraintContext(cursorAtCapturedNode));
+                    if (!constraintResult) {
+                        this.debug.log('info', 'constraint', `Constraint failed for capture: ${captureMarker.captureName}`);
+                        this.debug.setExplanation('constraint-failed', `Capture ${captureMarker.captureName} with valid constraint`, `Constraint failed for ${p.kind}`, `Constraint evaluation returned false`);
                         return this.abort(j);
                     }
-                    return j;
+                    this.debug.log('debug', 'constraint', `Constraint passed for capture: ${captureMarker.captureName}`);
                 }
-                finally {
-                    this.targetCursor = savedTargetCursor;
+                const success = this.matcher.handleCapture(captureMarker, p, undefined);
+                if (!success) {
+                    return this.abort(j);
                 }
-            }
-            return yield _super.visit.call(this, j, p, parent);
-        });
-    }
-    visitElement(j, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match) {
                 return j;
             }
-            const kindStr = this.formatKind(j.kind);
-            if (j.kind !== other.kind) {
-                return this.abort(j, 'kind-mismatch', 'kind', kindStr, this.formatKind(other.kind));
+            finally {
+                this.targetCursor = savedTargetCursor;
             }
-            for (const key of Object.keys(j)) {
-                if (key.startsWith('_') || key === 'kind' || key === 'id' || key === 'markers' || key === 'prefix') {
-                    continue;
-                }
-                const jValue = j[key];
-                const otherValue = other[key];
-                if (Array.isArray(jValue)) {
-                    if (!Array.isArray(otherValue) || jValue.length !== otherValue.length) {
-                        this.debug.pushPath(`${kindStr}#${key}`);
-                        const result = this.abort(j, 'array-length-mismatch', key, jValue.length, Array.isArray(otherValue) ? otherValue.length : otherValue);
-                        this.debug.popPath();
-                        return result;
-                    }
-                    for (let i = 0; i < jValue.length; i++) {
-                        this.debug.pushPath(`${kindStr}#${key}`);
-                        this.debug.pushPath(i.toString());
-                        try {
-                            yield this.visitProperty(jValue[i], otherValue[i]);
-                            if (!this.match) {
-                                return j;
-                            }
-                        }
-                        finally {
-                            this.debug.popPath();
-                            this.debug.popPath();
-                        }
-                    }
+        }
+        return await super.visit(j, p, parent);
+    }
+    async visitElement(j, other) {
+        if (!this.match) {
+            return j;
+        }
+        const kindStr = this.formatKind(j.kind);
+        if (j.kind !== other.kind) {
+            return this.abort(j, 'kind-mismatch', 'kind', kindStr, this.formatKind(other.kind));
+        }
+        for (const key of Object.keys(j)) {
+            if (key.startsWith('_') || key === 'kind' || key === 'id' || key === 'markers' || key === 'prefix') {
+                continue;
+            }
+            const jValue = j[key];
+            const otherValue = other[key];
+            if (Array.isArray(jValue)) {
+                if (!Array.isArray(otherValue) || jValue.length !== otherValue.length) {
+                    this.debug.pushPath(`${kindStr}#${key}`);
+                    const result = this.abort(j, 'array-length-mismatch', key, jValue.length, Array.isArray(otherValue) ? otherValue.length : otherValue);
+                    this.debug.popPath();
+                    return result;
                 }
-                else {
+                for (let i = 0; i < jValue.length; i++) {
                     this.debug.pushPath(`${kindStr}#${key}`);
+                    this.debug.pushPath(i.toString());
                     try {
-                        yield this.visitProperty(jValue, otherValue);
+                        await this.visitProperty(jValue[i], otherValue[i]);
                         if (!this.match) {
                             return j;
                         }
                     }
                     finally {
                         this.debug.popPath();
+                        this.debug.popPath();
                     }
                 }
             }
-            return j;
-        });
-    }
-    visitRightPadded(right, p) {
-        const _super = Object.create(null, {
-            visitRightPadded: { get: () => super.visitRightPadded }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match) {
-                return right;
-            }
-            const captureMarker = utils_1.PlaceholderUtils.getCaptureMarker(right);
-            if (captureMarker) {
-                const isRightPadded = p.kind === java_1.J.Kind.RightPadded;
-                const targetWrapper = isRightPadded ? p : undefined;
-                const targetElement = isRightPadded ? targetWrapper.element : p;
-                const savedTargetCursor = this.targetCursor;
-                const cursorAtCapturedNode = this.targetCursor !== undefined
-                    ? (targetWrapper ? new __1.Cursor(targetWrapper, this.targetCursor) : new __1.Cursor(targetElement, this.targetCursor))
-                    : (targetWrapper ? new __1.Cursor(targetWrapper) : new __1.Cursor(targetElement));
-                this.targetCursor = cursorAtCapturedNode;
+            else {
+                this.debug.pushPath(`${kindStr}#${key}`);
                 try {
-                    if (captureMarker.constraint && !captureMarker.variadicOptions) {
-                        this.debug.log('debug', 'constraint', `Evaluating constraint for wrapped capture: ${captureMarker.captureName}`);
-                        const constraintResult = captureMarker.constraint(targetElement, this.buildConstraintContext(cursorAtCapturedNode));
-                        if (!constraintResult) {
-                            this.debug.log('info', 'constraint', `Constraint failed for wrapped capture: ${captureMarker.captureName}`);
-                            this.debug.setExplanation('constraint-failed', `Capture ${captureMarker.captureName} with valid constraint`, `Constraint failed for ${targetElement.kind}`, `Constraint evaluation returned false`);
-                            return this.abort(right);
-                        }
-                        this.debug.log('debug', 'constraint', `Constraint passed for wrapped capture: ${captureMarker.captureName}`);
+                    await this.visitProperty(jValue, otherValue);
+                    if (!this.match) {
+                        return j;
                     }
-                    const success = this.matcher.handleCapture(captureMarker, targetElement, targetWrapper);
-                    if (!success) {
-                        return this.abort(right);
-                    }
-                    return right;
                 }
                 finally {
-                    this.targetCursor = savedTargetCursor;
+                    this.debug.popPath();
                 }
             }
-            return yield _super.visitRightPadded.call(this, right, p);
-        });
+        }
+        return j;
     }
-    visitContainer(container, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match) {
-                return container;
-            }
-            const isContainer = p.kind === java_1.J.Kind.Container;
-            if (!isContainer) {
-                return this.abort(container);
-            }
-            const otherContainer = p;
-            const hasVariadicCapture = container.elements.some(elem => utils_1.PlaceholderUtils.isVariadicCapture(elem));
-            const savedCursor = this.cursor;
+    async visitRightPadded(right, p) {
+        if (!this.match) {
+            return right;
+        }
+        const captureMarker = utils_1.PlaceholderUtils.getCaptureMarker(right);
+        if (captureMarker) {
+            const isRightPadded = p.kind === java_1.J.Kind.RightPadded;
+            const targetWrapper = isRightPadded ? p : undefined;
+            const targetElement = isRightPadded ? targetWrapper.element : p;
             const savedTargetCursor = this.targetCursor;
-            this.cursor = new __1.Cursor(container, this.cursor);
-            this.targetCursor = new __1.Cursor(otherContainer, this.targetCursor);
+            const cursorAtCapturedNode = this.targetCursor !== undefined
+                ? (targetWrapper ? new __1.Cursor(targetWrapper, this.targetCursor) : new __1.Cursor(targetElement, this.targetCursor))
+                : (targetWrapper ? new __1.Cursor(targetWrapper) : new __1.Cursor(targetElement));
+            this.targetCursor = cursorAtCapturedNode;
             try {
-                if (hasVariadicCapture) {
-                    if (!(yield this.matchSequence(container.elements, otherContainer.elements, true))) {
-                        return this.arrayLengthMismatch('elements');
+                if (captureMarker.constraint && !captureMarker.variadicOptions) {
+                    this.debug.log('debug', 'constraint', `Evaluating constraint for wrapped capture: ${captureMarker.captureName}`);
+                    const constraintResult = captureMarker.constraint(targetElement, this.buildConstraintContext(cursorAtCapturedNode));
+                    if (!constraintResult) {
+                        this.debug.log('info', 'constraint', `Constraint failed for wrapped capture: ${captureMarker.captureName}`);
+                        this.debug.setExplanation('constraint-failed', `Capture ${captureMarker.captureName} with valid constraint`, `Constraint failed for ${targetElement.kind}`, `Constraint evaluation returned false`);
+                        return this.abort(right);
                     }
+                    this.debug.log('debug', 'constraint', `Constraint passed for wrapped capture: ${captureMarker.captureName}`);
                 }
-                else {
-                    // Non-variadic path - track indices
-                    if (container.elements.length !== otherContainer.elements.length) {
-                        return this.arrayLengthMismatch('elements');
-                    }
-                    for (let i = 0; i < container.elements.length; i++) {
-                        this.debug.pushPath(i.toString());
-                        try {
-                            if (!(yield this.visitContainerElement(container.elements[i], otherContainer.elements[i], i))) {
-                                return container;
-                            }
-                        }
-                        finally {
-                            this.debug.popPath();
-                        }
-                    }
+                const success = this.matcher.handleCapture(captureMarker, targetElement, targetWrapper);
+                if (!success) {
+                    return this.abort(right);
                 }
+                return right;
             }
             finally {
-                this.cursor = savedCursor;
                 this.targetCursor = savedTargetCursor;
             }
+        }
+        return await super.visitRightPadded(right, p);
+    }
+    async visitContainer(container, p) {
+        if (!this.match) {
             return container;
-        });
+        }
+        const isContainer = p.kind === java_1.J.Kind.Container;
+        if (!isContainer) {
+            return this.abort(container);
+        }
+        const otherContainer = p;
+        const hasVariadicCapture = container.elements.some(elem => utils_1.PlaceholderUtils.isVariadicCapture(elem));
+        const savedCursor = this.cursor;
+        const savedTargetCursor = this.targetCursor;
+        this.cursor = new __1.Cursor(container, this.cursor);
+        this.targetCursor = new __1.Cursor(otherContainer, this.targetCursor);
+        try {
+            if (hasVariadicCapture) {
+                if (!await this.matchSequence(container.elements, otherContainer.elements, true)) {
+                    return this.arrayLengthMismatch('elements');
+                }
+            }
+            else {
+                // Non-variadic path - track indices
+                if (container.elements.length !== otherContainer.elements.length) {
+                    return this.arrayLengthMismatch('elements');
+                }
+                for (let i = 0; i < container.elements.length; i++) {
+                    this.debug.pushPath(i.toString());
+                    try {
+                        if (!await this.visitContainerElement(container.elements[i], otherContainer.elements[i], i)) {
+                            return container;
+                        }
+                    }
+                    finally {
+                        this.debug.popPath();
+                    }
+                }
+            }
+        }
+        finally {
+            this.cursor = savedCursor;
+            this.targetCursor = savedTargetCursor;
+        }
+        return container;
     }
     /**
      * Override visitContainerProperty to add path tracking with property context.
      */
-    visitContainerProperty(propertyName, container, otherContainer) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // Get parent from cursor
-            const parent = this.cursor.value;
-            // Push path for the property
-            const kindStr = this.formatKind(parent.kind);
-            this.debug.pushPath(`${kindStr}#${propertyName}`);
-            try {
-                yield this.visitContainer(container, otherContainer);
-                return container;
-            }
-            finally {
-                this.debug.popPath();
-            }
-        });
+    async visitContainerProperty(propertyName, container, otherContainer) {
+        // Get parent from cursor
+        const parent = this.cursor.value;
+        // Push path for the property
+        const kindStr = this.formatKind(parent.kind);
+        this.debug.pushPath(`${kindStr}#${propertyName}`);
+        try {
+            await this.visitContainer(container, otherContainer);
+            return container;
+        }
+        finally {
+            this.debug.popPath();
+        }
     }
     /**
      * Override visitRightPaddedProperty to add path tracking with property context.
      */
-    visitRightPaddedProperty(propertyName, rightPadded, otherRightPadded) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // Get parent from cursor
-            const parent = this.cursor.value;
-            // Push path for the property
-            const kindStr = this.formatKind(parent.kind);
-            this.debug.pushPath(`${kindStr}#${propertyName}`);
-            try {
-                return yield this.visitRightPadded(rightPadded, otherRightPadded);
-            }
-            finally {
-                this.debug.popPath();
-            }
-        });
+    async visitRightPaddedProperty(propertyName, rightPadded, otherRightPadded) {
+        // Get parent from cursor
+        const parent = this.cursor.value;
+        // Push path for the property
+        const kindStr = this.formatKind(parent.kind);
+        this.debug.pushPath(`${kindStr}#${propertyName}`);
+        try {
+            return await this.visitRightPadded(rightPadded, otherRightPadded);
+        }
+        finally {
+            this.debug.popPath();
+        }
     }
     /**
      * Override visitLeftPaddedProperty to add path tracking with property context.
      */
-    visitLeftPaddedProperty(propertyName, leftPadded, otherLeftPadded) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // Get parent from cursor
-            const parent = this.cursor.value;
-            // Push path for the property
-            const kindStr = this.formatKind(parent.kind);
-            this.debug.pushPath(`${kindStr}#${propertyName}`);
-            try {
-                return yield this.visitLeftPadded(leftPadded, otherLeftPadded);
-            }
-            finally {
-                this.debug.popPath();
-            }
-        });
+    async visitLeftPaddedProperty(propertyName, leftPadded, otherLeftPadded) {
+        // Get parent from cursor
+        const parent = this.cursor.value;
+        // Push path for the property
+        const kindStr = this.formatKind(parent.kind);
+        this.debug.pushPath(`${kindStr}#${propertyName}`);
+        try {
+            return await this.visitLeftPadded(leftPadded, otherLeftPadded);
+        }
+        finally {
+            this.debug.popPath();
+        }
     }
-    visitContainerElement(element, otherElement, index) {
-        const _super = Object.create(null, {
-            visitContainerElement: { get: () => super.visitContainerElement }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            // Don't push index here - it should be handled by the caller with proper context
-            return yield _super.visitContainerElement.call(this, element, otherElement, index);
-        });
+    async visitContainerElement(element, otherElement, index) {
+        // Don't push index here - it should be handled by the caller with proper context
+        return await super.visitContainerElement(element, otherElement, index);
     }
-    visitArrayProperty(parent, propertyName, array1, array2, visitor) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // Push path for the property
-            const kindStr = this.formatKind(parent.kind);
-            this.debug.pushPath(`${kindStr}#${propertyName}`);
-            try {
-                // Check length mismatch (will have path context)
-                if (array1.length !== array2.length) {
-                    this.arrayLengthMismatch(propertyName);
-                    return;
-                }
-                // Visit each element with index tracking
-                for (let i = 0; i < array1.length; i++) {
-                    this.debug.pushPath(i.toString());
-                    try {
-                        yield visitor(array1[i], array2[i], i);
-                        if (!this.match) {
-                            return;
-                        }
-                    }
-                    finally {
-                        this.debug.popPath();
-                    }
-                }
-            }
-            finally {
-                this.debug.popPath();
+    async visitArrayProperty(parent, propertyName, array1, array2, visitor) {
+        // Push path for the property
+        const kindStr = this.formatKind(parent.kind);
+        this.debug.pushPath(`${kindStr}#${propertyName}`);
+        try {
+            // Check length mismatch (will have path context)
+            if (array1.length !== array2.length) {
+                this.arrayLengthMismatch(propertyName);
+                return;
             }
-        });
-    }
-    matchSequence(patternElements, targetElements, filterEmpty) {
-        const _super = Object.create(null, {
-            matchSequence: { get: () => super.matchSequence }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b;
-            // Push path component for the container
-            // Extract kind from cursors if available
-            const pattern = (_a = this.cursor) === null || _a === void 0 ? void 0 : _a.value;
-            if (pattern && pattern.kind) {
-                const kindStr = this.formatKind(pattern.kind);
-                // Determine property name based on the kind
-                let propertyName = 'elements';
-                if (pattern.kind.includes('MethodInvocation')) {
-                    propertyName = 'arguments';
-                }
-                else if (pattern.kind.includes('Block')) {
-                    propertyName = 'statements';
+            // Visit each element with index tracking
+            for (let i = 0; i < array1.length; i++) {
+                this.debug.pushPath(i.toString());
+                try {
+                    await visitor(array1[i], array2[i], i);
+                    if (!this.match) {
+                        return;
+                    }
                 }
-                this.debug.pushPath(`${kindStr}#${propertyName}`);
-            }
-            try {
-                return yield _super.matchSequence.call(this, patternElements, targetElements, filterEmpty);
-            }
-            finally {
-                if ((_b = this.cursor) === null || _b === void 0 ? void 0 : _b.value) {
+                finally {
                     this.debug.popPath();
                 }
             }
-        });
+        }
+        finally {
+            this.debug.popPath();
+        }
     }
-    visitSequenceElement(patternWrapper, targetWrapper, targetIdx) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.debug.pushPath(targetIdx.toString());
-            try {
-                // Save current state for backtracking (both match state and capture bindings)
-                const savedMatch = this.match;
-                const savedState = this.matcher.saveState();
-                yield this.visitRightPadded(patternWrapper, targetWrapper);
-                if (!this.match) {
-                    // Preserve explanation before restoring state
-                    const explanation = this.debug.getExplanation();
-                    // Restore state on match failure
-                    this.match = savedMatch;
-                    this.matcher.restoreState(savedState);
-                    // Restore the explanation if one was set during matching
-                    if (explanation) {
-                        this.debug.restoreExplanation(explanation);
-                    }
-                    return false;
-                }
-                return true;
+    async matchSequence(patternElements, targetElements, filterEmpty) {
+        var _a, _b;
+        // Push path component for the container
+        // Extract kind from cursors if available
+        const pattern = (_a = this.cursor) === null || _a === void 0 ? void 0 : _a.value;
+        if (pattern && pattern.kind) {
+            const kindStr = this.formatKind(pattern.kind);
+            // Determine property name based on the kind
+            let propertyName = 'elements';
+            if (pattern.kind.includes('MethodInvocation')) {
+                propertyName = 'arguments';
             }
-            finally {
+            else if (pattern.kind.includes('Block')) {
+                propertyName = 'statements';
+            }
+            this.debug.pushPath(`${kindStr}#${propertyName}`);
+        }
+        try {
+            return await super.matchSequence(patternElements, targetElements, filterEmpty);
+        }
+        finally {
+            if ((_b = this.cursor) === null || _b === void 0 ? void 0 : _b.value) {
                 this.debug.popPath();
             }
-        });
+        }
     }
-    matchSequenceOptimized(patternElements, targetElements, patternIdx, targetIdx, filterEmpty) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b;
-            if (patternIdx >= patternElements.length) {
-                return targetIdx >= targetElements.length;
-            }
-            const patternWrapper = patternElements[patternIdx];
-            const captureMarker = utils_1.PlaceholderUtils.getCaptureMarker(patternWrapper);
-            const isVariadic = (captureMarker === null || captureMarker === void 0 ? void 0 : captureMarker.variadicOptions) !== undefined;
-            if (isVariadic) {
-                const variadicOptions = captureMarker.variadicOptions;
-                const min = (_a = variadicOptions === null || variadicOptions === void 0 ? void 0 : variadicOptions.min) !== null && _a !== void 0 ? _a : 0;
-                const max = (_b = variadicOptions === null || variadicOptions === void 0 ? void 0 : variadicOptions.max) !== null && _b !== void 0 ? _b : Infinity;
-                let nonVariadicRemainingPatterns = 0;
-                let allRemainingPatternsAreDeterministic = true;
-                for (let i = patternIdx + 1; i < patternElements.length; i++) {
-                    const nextCaptureMarker = utils_1.PlaceholderUtils.getCaptureMarker(patternElements[i]);
-                    const nextIsVariadic = (nextCaptureMarker === null || nextCaptureMarker === void 0 ? void 0 : nextCaptureMarker.variadicOptions) !== undefined;
-                    if (!nextIsVariadic) {
-                        nonVariadicRemainingPatterns++;
-                    }
-                    if (nextCaptureMarker) {
-                        allRemainingPatternsAreDeterministic = false;
-                    }
+    async visitSequenceElement(patternWrapper, targetWrapper, targetIdx) {
+        this.debug.pushPath(targetIdx.toString());
+        try {
+            // Save current state for backtracking (both match state and capture bindings)
+            const savedMatch = this.match;
+            const savedState = this.matcher.saveState();
+            await this.visitRightPadded(patternWrapper, targetWrapper);
+            if (!this.match) {
+                // Preserve explanation before restoring state
+                const explanation = this.debug.getExplanation();
+                // Restore state on match failure
+                this.match = savedMatch;
+                this.matcher.restoreState(savedState);
+                // Restore the explanation if one was set during matching
+                if (explanation) {
+                    this.debug.restoreExplanation(explanation);
                 }
-                const remainingTargetElements = targetElements.length - targetIdx;
-                const maxPossible = Math.min(remainingTargetElements - nonVariadicRemainingPatterns, max);
-                let pivotDetected = false;
-                let pivotAt = -1;
-                // Skip pivot detection if we're using deterministic optimization
-                // (when all remaining patterns are literals, there's only ONE valid consumption amount)
-                const useDeterministicOptimization = allRemainingPatternsAreDeterministic && maxPossible >= min && maxPossible <= max;
-                if (!useDeterministicOptimization && patternIdx + 1 < patternElements.length && min <= maxPossible) {
-                    const nextPattern = patternElements[patternIdx + 1];
-                    for (let tryConsume = min; tryConsume <= maxPossible; tryConsume++) {
-                        if (targetIdx + tryConsume < targetElements.length) {
-                            const candidateElement = targetElements[targetIdx + tryConsume];
-                            if (filterEmpty && candidateElement.element.kind === java_1.J.Kind.Empty) {
-                                continue;
-                            }
-                            const savedMatch = this.match;
-                            const savedState = this.matcher.saveState();
-                            yield this.visitRightPadded(nextPattern, candidateElement);
-                            const matchesNext = this.match;
-                            this.match = savedMatch;
-                            this.matcher.restoreState(savedState);
-                            if (matchesNext) {
-                                pivotDetected = true;
-                                pivotAt = tryConsume;
-                                break;
-                            }
-                        }
-                    }
+                return false;
+            }
+            return true;
+        }
+        finally {
+            this.debug.popPath();
+        }
+    }
+    async matchSequenceOptimized(patternElements, targetElements, patternIdx, targetIdx, filterEmpty) {
+        var _a, _b;
+        if (patternIdx >= patternElements.length) {
+            return targetIdx >= targetElements.length;
+        }
+        const patternWrapper = patternElements[patternIdx];
+        const captureMarker = utils_1.PlaceholderUtils.getCaptureMarker(patternWrapper);
+        const isVariadic = (captureMarker === null || captureMarker === void 0 ? void 0 : captureMarker.variadicOptions) !== undefined;
+        if (isVariadic) {
+            const variadicOptions = captureMarker.variadicOptions;
+            const min = (_a = variadicOptions === null || variadicOptions === void 0 ? void 0 : variadicOptions.min) !== null && _a !== void 0 ? _a : 0;
+            const max = (_b = variadicOptions === null || variadicOptions === void 0 ? void 0 : variadicOptions.max) !== null && _b !== void 0 ? _b : Infinity;
+            let nonVariadicRemainingPatterns = 0;
+            let allRemainingPatternsAreDeterministic = true;
+            for (let i = patternIdx + 1; i < patternElements.length; i++) {
+                const nextCaptureMarker = utils_1.PlaceholderUtils.getCaptureMarker(patternElements[i]);
+                const nextIsVariadic = (nextCaptureMarker === null || nextCaptureMarker === void 0 ? void 0 : nextCaptureMarker.variadicOptions) !== undefined;
+                if (!nextIsVariadic) {
+                    nonVariadicRemainingPatterns++;
                 }
-                const consumptionOrder = [];
-                // OPTIMIZATION: If all remaining patterns are deterministic (literals, not captures),
-                // there's only ONE mathematically valid consumption amount. Skip backtracking entirely.
-                // Example: foo(${args}, 999) matching foo(1,2,42) -> args MUST be [1,2], only try consume=2
-                if (useDeterministicOptimization) {
-                    consumptionOrder.push(maxPossible);
+                if (nextCaptureMarker) {
+                    allRemainingPatternsAreDeterministic = false;
                 }
-                else if (pivotDetected && pivotAt >= 0) {
-                    consumptionOrder.push(pivotAt);
-                    for (let c = maxPossible; c >= min; c--) {
-                        if (c !== pivotAt) {
-                            consumptionOrder.push(c);
+            }
+            const remainingTargetElements = targetElements.length - targetIdx;
+            const maxPossible = Math.min(remainingTargetElements - nonVariadicRemainingPatterns, max);
+            let pivotDetected = false;
+            let pivotAt = -1;
+            // Skip pivot detection if we're using deterministic optimization
+            // (when all remaining patterns are literals, there's only ONE valid consumption amount)
+            const useDeterministicOptimization = allRemainingPatternsAreDeterministic && maxPossible >= min && maxPossible <= max;
+            if (!useDeterministicOptimization && patternIdx + 1 < patternElements.length && min <= maxPossible) {
+                const nextPattern = patternElements[patternIdx + 1];
+                for (let tryConsume = min; tryConsume <= maxPossible; tryConsume++) {
+                    if (targetIdx + tryConsume < targetElements.length) {
+                        const candidateElement = targetElements[targetIdx + tryConsume];
+                        if (filterEmpty && candidateElement.element.kind === java_1.J.Kind.Empty) {
+                            continue;
+                        }
+                        const savedMatch = this.match;
+                        const savedState = this.matcher.saveState();
+                        await this.visitRightPadded(nextPattern, candidateElement);
+                        const matchesNext = this.match;
+                        this.match = savedMatch;
+                        this.matcher.restoreState(savedState);
+                        if (matchesNext) {
+                            pivotDetected = true;
+                            pivotAt = tryConsume;
+                            break;
                         }
                     }
                 }
-                else {
-                    for (let c = maxPossible; c >= min; c--) {
+            }
+            const consumptionOrder = [];
+            // OPTIMIZATION: If all remaining patterns are deterministic (literals, not captures),
+            // there's only ONE mathematically valid consumption amount. Skip backtracking entirely.
+            // Example: foo(${args}, 999) matching foo(1,2,42) -> args MUST be [1,2], only try consume=2
+            if (useDeterministicOptimization) {
+                consumptionOrder.push(maxPossible);
+            }
+            else if (pivotDetected && pivotAt >= 0) {
+                consumptionOrder.push(pivotAt);
+                for (let c = maxPossible; c >= min; c--) {
+                    if (c !== pivotAt) {
                         consumptionOrder.push(c);
                     }
                 }
-                for (const consume of consumptionOrder) {
-                    // Capture elements for this consumption amount
-                    // For empty argument lists, there will be a single J.Empty element that we need to filter out
-                    const rawWrappers = targetElements.slice(targetIdx, targetIdx + consume);
-                    const capturedWrappers = filterEmpty
-                        ? rawWrappers.filter(w => w.element.kind !== java_1.J.Kind.Empty)
-                        : rawWrappers;
-                    const capturedElements = capturedWrappers.map(w => w.element);
-                    // Check min/max constraints against filtered elements
-                    if (capturedElements.length < min || capturedElements.length > max) {
-                        continue;
-                    }
-                    if (captureMarker.constraint) {
-                        this.debug.log('debug', 'constraint', `Evaluating variadic constraint for capture: ${captureMarker.captureName} (${capturedElements.length} elements)`);
-                        const cursor = this.targetCursor || new __1.Cursor(targetElements[0]);
-                        const constraintResult = captureMarker.constraint(capturedElements, this.buildConstraintContext(cursor));
-                        if (!constraintResult) {
-                            this.debug.log('info', 'constraint', `Variadic constraint failed for capture: ${captureMarker.captureName}`);
-                            continue;
-                        }
-                        this.debug.log('debug', 'constraint', `Variadic constraint passed for capture: ${captureMarker.captureName}`);
-                    }
-                    const savedState = this.matcher.saveState();
-                    const success = this.matcher.handleVariadicCapture(captureMarker, capturedElements, capturedWrappers);
-                    if (!success) {
-                        this.matcher.restoreState(savedState);
+            }
+            else {
+                for (let c = maxPossible; c >= min; c--) {
+                    consumptionOrder.push(c);
+                }
+            }
+            for (const consume of consumptionOrder) {
+                // Capture elements for this consumption amount
+                // For empty argument lists, there will be a single J.Empty element that we need to filter out
+                const rawWrappers = targetElements.slice(targetIdx, targetIdx + consume);
+                const capturedWrappers = filterEmpty
+                    ? rawWrappers.filter(w => w.element.kind !== java_1.J.Kind.Empty)
+                    : rawWrappers;
+                const capturedElements = capturedWrappers.map(w => w.element);
+                // Check min/max constraints against filtered elements
+                if (capturedElements.length < min || capturedElements.length > max) {
+                    continue;
+                }
+                if (captureMarker.constraint) {
+                    this.debug.log('debug', 'constraint', `Evaluating variadic constraint for capture: ${captureMarker.captureName} (${capturedElements.length} elements)`);
+                    const cursor = this.targetCursor || new __1.Cursor(targetElements[0]);
+                    const constraintResult = captureMarker.constraint(capturedElements, this.buildConstraintContext(cursor));
+                    if (!constraintResult) {
+                        this.debug.log('info', 'constraint', `Variadic constraint failed for capture: ${captureMarker.captureName}`);
                         continue;
                     }
-                    const restMatches = yield this.matchSequenceOptimized(patternElements, targetElements, patternIdx + 1, targetIdx + consume, filterEmpty);
-                    if (restMatches) {
-                        return true;
-                    }
-                    // Preserve explanation from this failed attempt before restoring state
-                    // This is especially important when using deterministic optimization (only one attempt)
-                    const currentExplanation = this.debug.getExplanation();
-                    this.matcher.restoreState(savedState);
-                    // Restore the explanation if one was set during this attempt
-                    if (currentExplanation) {
-                        this.debug.restoreExplanation(currentExplanation);
-                    }
+                    this.debug.log('debug', 'constraint', `Variadic constraint passed for capture: ${captureMarker.captureName}`);
                 }
-                return false;
-            }
-            else {
-                if (targetIdx >= targetElements.length) {
-                    return false;
+                const savedState = this.matcher.saveState();
+                const success = this.matcher.handleVariadicCapture(captureMarker, capturedElements, capturedWrappers);
+                if (!success) {
+                    this.matcher.restoreState(savedState);
+                    continue;
                 }
-                const targetWrapper = targetElements[targetIdx];
-                const targetElement = targetWrapper.element;
-                if (filterEmpty && targetElement.kind === java_1.J.Kind.Empty) {
-                    return false;
+                const restMatches = await this.matchSequenceOptimized(patternElements, targetElements, patternIdx + 1, targetIdx + consume, filterEmpty);
+                if (restMatches) {
+                    return true;
                 }
-                if (!(yield this.visitSequenceElement(patternWrapper, targetWrapper, targetIdx))) {
-                    return false;
+                // Preserve explanation from this failed attempt before restoring state
+                // This is especially important when using deterministic optimization (only one attempt)
+                const currentExplanation = this.debug.getExplanation();
+                this.matcher.restoreState(savedState);
+                // Restore the explanation if one was set during this attempt
+                if (currentExplanation) {
+                    this.debug.restoreExplanation(currentExplanation);
                 }
-                return yield this.matchSequenceOptimized(patternElements, targetElements, patternIdx + 1, targetIdx + 1, filterEmpty);
             }
-        });
+            return false;
+        }
+        else {
+            if (targetIdx >= targetElements.length) {
+                return false;
+            }
+            const targetWrapper = targetElements[targetIdx];
+            const targetElement = targetWrapper.element;
+            if (filterEmpty && targetElement.kind === java_1.J.Kind.Empty) {
+                return false;
+            }
+            if (!await this.visitSequenceElement(patternWrapper, targetWrapper, targetIdx)) {
+                return false;
+            }
+            return await this.matchSequenceOptimized(patternElements, targetElements, patternIdx + 1, targetIdx + 1, filterEmpty);
+        }
     }
 }
 exports.DebugPatternMatchingComparator = DebugPatternMatchingComparator;