@openrewrite/rewrite 8.67.0-20251112-160335 → 8.67.0-20251113-160321

package/dist/javascript/templating/comparator.js

@@ -9,7 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PatternMatchingComparator = void 0;
+exports.DebugPatternMatchingComparator = exports.PatternMatchingComparator = void 0;
 /*
  * Copyright 2025 the original author or authors.
  * <p>
@@ -62,11 +62,14 @@ class PatternMatchingComparator extends comparator_1.JavaScriptSemanticComparato
                     // 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(p, cursorAtCapturedNode)) {
-                        return this.abort(j);
+                        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) {
-                        return this.abort(j);
+                        const captureName = captureMarker.captureName || 'unnamed';
+                        return this.captureConflict(captureName);
                     }
                     return j;
                 }
@@ -85,6 +88,19 @@ class PatternMatchingComparator extends comparator_1.JavaScriptSemanticComparato
         return super.hasSameKind(j, other) ||
             (j.kind == java_1.J.Kind.Identifier && utils_1.PlaceholderUtils.isCapture(j));
     }
+    /**
+     * Additional specialized abort methods for pattern matching scenarios.
+     */
+    constraintFailed(captureName, targetKind) {
+        var _a;
+        const pattern = (_a = this.cursor) === null || _a === void 0 ? void 0 : _a.value;
+        return this.abort(pattern, 'constraint-failed', `capture[${captureName}]`, 'constraint satisfied', `constraint failed for ${targetKind}`);
+    }
+    captureConflict(captureName) {
+        var _a;
+        const pattern = (_a = this.cursor) === null || _a === void 0 ? void 0 : _a.value;
+        return this.abort(pattern, 'capture-conflict', `capture[${captureName}]`, 'compatible binding', 'conflicting binding');
+    }
     /**
      * Override visitRightPadded to check if this wrapper has a CaptureMarker.
      * If so, capture the entire wrapper (to preserve markers like semicolons).
@@ -115,12 +131,15 @@ class PatternMatchingComparator extends comparator_1.JavaScriptSemanticComparato
                     // 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, cursorAtCapturedNode)) {
-                        return this.abort(right);
+                        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) {
-                        return this.abort(right);
+                        const captureName = captureMarker.captureName || 'unnamed';
+                        return this.captureConflict(captureName);
                     }
                     return right;
                 }
@@ -150,7 +169,18 @@ class PatternMatchingComparator extends comparator_1.JavaScriptSemanticComparato
             // Extract the other container
             const isContainer = p.kind === java_1.J.Kind.Container;
             if (!isContainer) {
-                return this.abort(container);
+                // 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;
+                }
             }
             const otherContainer = p;
             // Push wrappers onto both cursors
@@ -162,7 +192,7 @@ class PatternMatchingComparator extends comparator_1.JavaScriptSemanticComparato
                 // 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.abort(container);
+                    return this.structuralMismatch('elements');
                 }
             }
             finally {
@@ -172,6 +202,21 @@ class PatternMatchingComparator extends comparator_1.JavaScriptSemanticComparato
             return container;
         });
     }
+    /**
+     * Visit a single element in a container (for non-variadic matching).
+     * Extracted to allow debug subclass to add path tracking.
+     *
+     * @param element The pattern element
+     * @param otherElement The target element
+     * @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;
+        });
+    }
     visitMethodInvocation(methodInvocation, other) {
         const _super = Object.create(null, {
             visitMethodInvocation: { get: () => super.visitMethodInvocation }
@@ -184,45 +229,71 @@ class PatternMatchingComparator extends comparator_1.JavaScriptSemanticComparato
                 return _super.visitMethodInvocation.call(this, methodInvocation, other);
             }
             // Otherwise, handle variadic captures ourselves
-            if (!this.match || other.kind !== java_1.J.Kind.MethodInvocation) {
-                return this.abort(methodInvocation);
-            }
-            const otherMethodInvocation = other;
-            // Compare select
-            if ((methodInvocation.select === undefined) !== (otherMethodInvocation.select === undefined)) {
+            if (!this.match) {
                 return this.abort(methodInvocation);
             }
-            // Visit select if present
-            if (methodInvocation.select && otherMethodInvocation.select) {
-                yield this.visit(methodInvocation.select.element, otherMethodInvocation.select.element);
-                if (!this.match)
-                    return methodInvocation;
-            }
-            // Compare typeParameters
-            if ((methodInvocation.typeParameters === undefined) !== (otherMethodInvocation.typeParameters === undefined)) {
-                return this.abort(methodInvocation);
+            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;
+                }
             }
-            // Visit typeParameters if present
-            if (methodInvocation.typeParameters && otherMethodInvocation.typeParameters) {
-                if (methodInvocation.typeParameters.elements.length !== otherMethodInvocation.typeParameters.elements.length) {
-                    return this.abort(methodInvocation);
+            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');
                 }
-                // 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]);
+                // Visit select if present
+                if (methodInvocation.select && otherMethodInvocation.select) {
+                    yield this.visit(methodInvocation.select.element, otherMethodInvocation.select.element);
                     if (!this.match)
                         return methodInvocation;
                 }
-            }
-            // Visit name
-            yield this.visit(methodInvocation.name, otherMethodInvocation.name);
-            if (!this.match)
+                // 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;
-            // Special handling for variadic captures in arguments
-            if (!(yield this.matchArguments(methodInvocation.arguments.elements, otherMethodInvocation.arguments.elements))) {
-                return this.abort(methodInvocation);
             }
-            return methodInvocation;
+            finally {
+                this.cursor = savedCursor;
+                this.targetCursor = savedTargetCursor;
+            }
         });
     }
     visitBlock(block, other) {
@@ -240,15 +311,40 @@ class PatternMatchingComparator extends comparator_1.JavaScriptSemanticComparato
                 return _super.visitBlock.call(this, block, other);
             }
             // Otherwise, handle variadic captures ourselves
-            if (!this.match || other.kind !== java_1.J.Kind.Block) {
+            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(other, this.targetCursor);
+                try {
+                    return this.kindMismatch();
+                }
+                finally {
+                    this.cursor = savedCursor;
+                    this.targetCursor = savedTargetCursor;
+                }
+            }
             const otherBlock = other;
-            // Special handling for variadic captures in statements
-            if (!(yield this.matchSequence(block.statements, otherBlock.statements, false))) {
-                return this.abort(block);
+            // 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 (!(yield this.matchSequence(block.statements, otherBlock.statements, false))) {
+                    return this.structuralMismatch('statements');
+                }
+                return block;
+            }
+            finally {
+                this.cursor = savedCursor;
+                this.targetCursor = savedTargetCursor;
             }
-            return block;
         });
     }
     visitJsCompilationUnit(compilationUnit, other) {
@@ -265,15 +361,40 @@ class PatternMatchingComparator extends comparator_1.JavaScriptSemanticComparato
                 return _super.visitJsCompilationUnit.call(this, compilationUnit, other);
             }
             // Otherwise, handle variadic captures ourselves
-            if (!this.match || other.kind !== index_1.JS.Kind.CompilationUnit) {
+            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;
-            // Special handling for variadic captures in top-level statements
-            if (!(yield this.matchSequence(compilationUnit.statements, otherCompilationUnit.statements, false))) {
-                return this.abort(compilationUnit);
+            // 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 (!(yield this.matchSequence(compilationUnit.statements, otherCompilationUnit.statements, false))) {
+                    return this.structuralMismatch('statements');
+                }
+                return compilationUnit;
+            }
+            finally {
+                this.cursor = savedCursor;
+                this.targetCursor = savedTargetCursor;
             }
-            return compilationUnit;
         });
     }
     /**
@@ -282,7 +403,7 @@ class PatternMatchingComparator extends comparator_1.JavaScriptSemanticComparato
      */
     matchArguments(patternArgs, targetArgs) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.matchSequence(patternArgs, targetArgs, true);
+            return yield this.matchSequence(patternArgs, targetArgs, true);
         });
     }
     /**
@@ -330,14 +451,20 @@ class PatternMatchingComparator extends comparator_1.JavaScriptSemanticComparato
                 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
+                // 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);
@@ -345,7 +472,10 @@ class PatternMatchingComparator extends comparator_1.JavaScriptSemanticComparato
                 // This avoids unnecessary backtracking when constraints make the split point obvious
                 let pivotDetected = false;
                 let pivotAt = -1;
-                if (patternIdx + 1 < patternElements.length && min <= maxPossible) {
+                // 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++) {
@@ -372,10 +502,15 @@ class PatternMatchingComparator extends comparator_1.JavaScriptSemanticComparato
                         }
                     }
                 }
-                // Try different consumption amounts
-                // If pivot detected, try that first; otherwise use greedy approach (max to min)
+                // Determine consumption order
                 const consumptionOrder = [];
-                if (pivotDetected && pivotAt >= 0) {
+                // 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--) {
@@ -392,21 +527,15 @@ class PatternMatchingComparator extends comparator_1.JavaScriptSemanticComparato
                 }
                 for (const consume of consumptionOrder) {
                     // Capture elements for this consumption amount
-                    const capturedWrappers = [];
-                    for (let i = 0; i < consume; i++) {
-                        const wrapped = targetElements[targetIdx + i];
-                        const element = wrapped.element;
-                        // For arguments, filter out J.Empty as it represents an empty argument list
-                        // For statements, include all elements
-                        if (!filterEmpty || element.kind !== java_1.J.Kind.Empty) {
-                            capturedWrappers.push(wrapped);
-                        }
-                    }
-                    // Extract just the elements for the constraint check
+                    // 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);
-                    // Re-check min/max constraints against actual captured elements (after filtering if applicable)
+                    // Check min/max constraints against filtered elements
                     if (capturedElements.length < min || capturedElements.length > max) {
-                        continue; // Try next consumption amount
+                        continue;
                     }
                     // Evaluate constraint for variadic capture
                     // For variadic captures, constraint receives the entire array of captured elements
@@ -447,27 +576,646 @@ class PatternMatchingComparator extends comparator_1.JavaScriptSemanticComparato
                 if (filterEmpty && targetElement.kind === java_1.J.Kind.Empty) {
                     return false;
                 }
+                if (!(yield this.visitSequenceElement(patternWrapper, targetWrapper, targetIdx))) {
+                    return false;
+                }
+                // Continue matching the rest
+                return yield this.matchSequenceOptimized(patternElements, targetElements, patternIdx + 1, targetIdx + 1, filterEmpty);
+            }
+        });
+    }
+    /**
+     * Visit a single element in a sequence during non-variadic matching.
+     * Extracted to allow debug subclass to add path tracking.
+     *
+     * @param patternWrapper The pattern element
+     * @param targetWrapper The target element
+     * @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;
+        });
+    }
+}
+exports.PatternMatchingComparator = PatternMatchingComparator;
+/**
+ * Debug-instrumented version of PatternMatchingComparator.
+ * Overrides methods to add path tracking, logging, and explanation capture.
+ * Zero cost when not instantiated - production code uses the base class.
+ */
+class DebugPatternMatchingComparator extends PatternMatchingComparator {
+    get debug() {
+        return this.matcher.debug;
+    }
+    /**
+     * Extracts the last segment of a kind string (after the last dot).
+     * For example: "org.openrewrite.java.tree.J.MethodInvocation" -> "MethodInvocation"
+     */
+    formatKind(kind) {
+        return kind.substring(kind.lastIndexOf('.') + 1);
+    }
+    /**
+     * Formats a value for display in error messages.
+     */
+    formatValue(value) {
+        if (value === null)
+            return 'null';
+        if (value === undefined)
+            return 'undefined';
+        if (typeof value === 'string')
+            return `"${value}"`;
+        if (typeof value === 'number' || typeof value === 'boolean')
+            return String(value);
+        // For objects with a kind property (LST nodes)
+        if (value && typeof value === 'object' && value.kind) {
+            const kind = this.formatKind(value.kind);
+            // Show key identifying properties for common node types
+            if (value.simpleName)
+                return `${kind}("${value.simpleName}")`;
+            if (value.value !== undefined)
+                return `${kind}(${this.formatValue(value.value)})`;
+            return kind;
+        }
+        return String(value);
+    }
+    /**
+     * Override abort to capture explanation when debug is enabled.
+     * Only sets explanation on the first abort call (when this.match is still true).
+     * This preserves the most specific explanation closest to the actual mismatch.
+     */
+    abort(t, reason, propertyName, expected, actual) {
+        // If already aborted, don't overwrite the explanation
+        // The first abort is typically the most specific
+        if (!this.match) {
+            return t;
+        }
+        // If we have context about the mismatch, capture it
+        if (reason && this.debug && (expected !== undefined || actual !== undefined)) {
+            const expectedStr = this.formatValue(expected);
+            const actualStr = this.formatValue(actual);
+            this.debug.setExplanation(reason, expectedStr, actualStr, 'Property values do not match');
+        }
+        // Set `this.match = false`
+        return super.abort(t, reason, propertyName, expected, actual);
+    }
+    /**
+     * Override helper methods to extract detailed context from cursors.
+     */
+    kindMismatch() {
+        var _a, _b;
+        const pattern = (_a = this.cursor) === null || _a === void 0 ? void 0 : _a.value;
+        const target = (_b = this.targetCursor) === null || _b === void 0 ? void 0 : _b.value;
+        // Pass the full kind strings - formatValue() will detect and format them
+        return this.abort(pattern, 'kind-mismatch', 'kind', this.formatKind(pattern === null || pattern === void 0 ? void 0 : pattern.kind), this.formatKind(target === null || target === void 0 ? void 0 : target.kind));
+    }
+    structuralMismatch(propertyName) {
+        var _a, _b;
+        const pattern = (_a = this.cursor) === null || _a === void 0 ? void 0 : _a.value;
+        const target = (_b = this.targetCursor) === null || _b === void 0 ? void 0 : _b.value;
+        const expectedValue = pattern === null || pattern === void 0 ? void 0 : pattern[propertyName];
+        const actualValue = target === null || target === void 0 ? void 0 : target[propertyName];
+        return this.abort(pattern, 'structural-mismatch', propertyName, expectedValue, actualValue);
+    }
+    arrayLengthMismatch(propertyName) {
+        var _a, _b;
+        const pattern = (_a = this.cursor) === null || _a === void 0 ? void 0 : _a.value;
+        const target = (_b = this.targetCursor) === null || _b === void 0 ? void 0 : _b.value;
+        const expectedArray = pattern === null || pattern === void 0 ? void 0 : pattern[propertyName];
+        const actualArray = target === null || target === void 0 ? void 0 : target[propertyName];
+        const expectedLen = Array.isArray(expectedArray) ? expectedArray.length : 'not an array';
+        const actualLen = Array.isArray(actualArray) ? actualArray.length : 'not an array';
+        return this.abort(pattern, 'array-length-mismatch', propertyName, expectedLen, actualLen);
+    }
+    valueMismatch(propertyName, expected, actual) {
+        var _a, _b;
+        const pattern = (_a = this.cursor) === null || _a === void 0 ? void 0 : _a.value;
+        const target = (_b = this.targetCursor) === null || _b === void 0 ? void 0 : _b.value;
+        // Track number of paths pushed for cleanup
+        let pathsPushed = 0;
+        // Handle path tracking only if propertyName is provided
+        if (propertyName) {
+            // Split dotted property paths (e.g., "name.simpleName" → ["name", "simpleName"])
+            const pathParts = propertyName.split('.');
+            pathsPushed = pathParts.length;
+            // Add each property to path with kind information for nested objects
+            const kindStr = this.formatKind(pattern === null || pattern === void 0 ? void 0 : pattern.kind);
+            this.debug.pushPath(`${kindStr}#${pathParts[0]}`);
+            // For nested properties, try to get the kind of intermediate objects
+            let currentObj = pattern === null || pattern === void 0 ? void 0 : pattern[pathParts[0]];
+            for (let i = 1; i < pathParts.length; i++) {
+                if (currentObj && typeof currentObj === 'object' && currentObj.kind) {
+                    // Include the kind of the nested object
+                    const nestedKind = this.formatKind(currentObj.kind);
+                    this.debug.pushPath(`${nestedKind}#${pathParts[i]}`);
+                }
+                else {
+                    // Fallback to just the property name if no kind available
+                    this.debug.pushPath(pathParts[i]);
+                }
+                currentObj = currentObj === null || currentObj === void 0 ? void 0 : currentObj[pathParts[i]];
+            }
+        }
+        try {
+            // If expected/actual provided, use them directly
+            if (expected !== undefined || actual !== undefined) {
+                return this.abort(pattern, 'value-mismatch', propertyName, expected, actual);
+            }
+            // Otherwise, try to extract from cursors (fallback for older code)
+            if (propertyName) {
+                // Navigate dotted property paths
+                const getNestedValue = (obj, path) => {
+                    return path.split('.').reduce((current, prop) => current === null || current === void 0 ? void 0 : current[prop], obj);
+                };
+                const expectedValue = getNestedValue(pattern, propertyName);
+                const actualValue = getNestedValue(target, propertyName);
+                return this.abort(pattern, 'value-mismatch', propertyName, expectedValue, actualValue);
+            }
+            else {
+                // No property name - compare whole objects
+                return this.abort(pattern, 'value-mismatch', propertyName, pattern, target);
+            }
+        }
+        finally {
+            // Pop all the path components we pushed
+            for (let i = 0; i < pathsPushed; i++) {
+                this.debug.popPath();
+            }
+        }
+    }
+    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, 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) {
+                        return this.abort(j);
+                    }
+                    return j;
+                }
+                finally {
+                    this.targetCursor = savedTargetCursor;
+                }
+            }
+            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));
+            }
+            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();
+                        }
+                    }
+                }
+                else {
+                    this.debug.pushPath(`${kindStr}#${key}`);
+                    try {
+                        yield this.visitProperty(jValue, otherValue);
+                        if (!this.match) {
+                            return j;
+                        }
+                    }
+                    finally {
+                        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;
+                try {
+                    if (captureMarker.constraint && !captureMarker.variadicOptions) {
+                        this.debug.log('debug', 'constraint', `Evaluating constraint for wrapped capture: ${captureMarker.captureName}`);
+                        const constraintResult = captureMarker.constraint(targetElement, 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}`);
+                    }
+                    const success = this.matcher.handleCapture(captureMarker, targetElement, targetWrapper);
+                    if (!success) {
+                        return this.abort(right);
+                    }
+                    return right;
+                }
+                finally {
+                    this.targetCursor = savedTargetCursor;
+                }
+            }
+            return yield _super.visitRightPadded.call(this, right, p);
+        });
+    }
+    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;
+            const savedTargetCursor = this.targetCursor;
+            this.cursor = new __1.Cursor(container, this.cursor);
+            this.targetCursor = new __1.Cursor(otherContainer, this.targetCursor);
+            try {
+                if (hasVariadicCapture) {
+                    if (!(yield 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 (!(yield 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();
+            }
+        });
+    }
+    /**
+     * 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();
+            }
+        });
+    }
+    /**
+     * 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();
+            }
+        });
+    }
+    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);
+        });
+    }
+    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();
+            }
+        });
+    }
+    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';
+                }
+                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) {
+                    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;
                 }
-                // Continue matching the rest
-                const restMatches = yield this.matchSequenceOptimized(patternElements, targetElements, patternIdx + 1, targetIdx + 1, filterEmpty);
-                if (!restMatches) {
-                    // Restore full state on backtracking failure
-                    this.match = savedMatch;
+                return true;
+            }
+            finally {
+                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;
+                    }
+                }
+                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;
+                            }
+                        }
+                    }
+                }
+                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);
+                        }
+                    }
+                }
+                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, 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);
+                        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);
+                    }
                 }
-                return restMatches;
+                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 (!(yield this.visitSequenceElement(patternWrapper, targetWrapper, targetIdx))) {
+                    return false;
+                }
+                return yield this.matchSequenceOptimized(patternElements, targetElements, patternIdx + 1, targetIdx + 1, filterEmpty);
             }
         });
     }
 }
-exports.PatternMatchingComparator = PatternMatchingComparator;
+exports.DebugPatternMatchingComparator = DebugPatternMatchingComparator;
 //# sourceMappingURL=comparator.js.map