Fix :not() silently dropping multi-segment selectors; bump v0.9.3

Custom rule selectors like `img:not(pl-overlay img)` were silently
ignored: `checkSelfNegations` skipped any `:not(...)` alternative with
more than one segment. Thread the cursor through `nodeMatchesSegment`
so multi-segment negations can reuse `checkPrefix` to validate the
ancestor/sibling chain, matching `Element.matches` semantics.

Covers descendant, child, and sibling combinators inside `:not()`,
including Mustache sections (e.g. `button:not({{#admin}} button)`).

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: Peter Stenger

lsp/package.json

@@ -664,6 +664,90 @@ describe('matchSelector', () => {
     expect(matches[0].text).toContain('id="no"');
   });
 
+  // --- Multi-segment :not() (descendant / child / sibling context) ---
+
+  it(':not(ancestor descendant) excludes nodes under the named ancestor', () => {
+    const tree = parseText(
+      '<pl-overlay><pl-background><img src="bg.png"></pl-background></pl-overlay>' +
+      '<figure><img src="other.png"></figure>' +
+      '<img src="standalone.png">',
+    );
+    const matches = matchSelector(
+      tree.rootNode,
+      parseSelector('img:not([style]):not([class]):not(pl-overlay img)')!,
+    );
+    // Only the figure img and the standalone img qualify; the pl-overlay img is excluded.
+    expect(matches).toHaveLength(2);
+    expect(matches.map(m => m.text).join(' ')).toMatch(/other\.png/);
+    expect(matches.map(m => m.text).join(' ')).toMatch(/standalone\.png/);
+    expect(matches.map(m => m.text).join(' ')).not.toMatch(/bg\.png/);
+  });
+
+  it(':not(ancestor descendant) still matches nodes without that ancestor', () => {
+    const tree = parseText('<section><img></section>');
+    const matches = matchSelector(
+      tree.rootNode,
+      parseSelector('img:not(pl-overlay img)')!,
+    );
+    expect(matches).toHaveLength(1);
+  });
+
+  it(':not(parent > child) excludes only direct children', () => {
+    const tree = parseText(
+      '<table><thead><td>a</td></thead><tbody><tr><td>b</td></tr></tbody></table>',
+    );
+    // Matches the td inside tbody > tr (not a direct child of thead), but excludes the
+    // td inside thead. Note the tbody-nested td is NOT excluded because the selector
+    // targets `thead > td`, and the nested td is a child of tr not thead.
+    const matches = matchSelector(
+      tree.rootNode,
+      parseSelector('td:not(thead > td)')!,
+    );
+    expect(matches).toHaveLength(1);
+    expect(matches[0].text).toContain('<td');
+  });
+
+  it(':not(a + b) excludes adjacent-sibling matches', () => {
+    const tree = parseText(
+      '<section><h2></h2><p id="after"></p></section>' +
+      '<section><div></div><p id="lonely"></p></section>',
+    );
+    const matches = matchSelector(
+      tree.rootNode,
+      parseSelector('p:not(h2 + p)')!,
+    );
+    // Only the p that is NOT directly after an h2 should match.
+    expect(matches).toHaveLength(1);
+    expect(matches[0].text).toContain('id="lonely"');
+  });
+
+  it(':not(ancestor descendant) nested in :has() composes correctly', () => {
+    const tree = parseText(
+      '<section><pl-overlay><img></pl-overlay><img id="raw"></section>' +
+      '<section><img id="alone"></section>',
+    );
+    // Section that contains an img not under pl-overlay.
+    const matches = matchSelector(
+      tree.rootNode,
+      parseSelector('section:has(img:not(pl-overlay img))')!,
+    );
+    // Both sections qualify: one has id="raw" outside pl-overlay, the other has id="alone".
+    expect(matches).toHaveLength(2);
+  });
+
+  it(':not(Mustache-section descendant) excludes nodes inside that section', () => {
+    const tree = parseText(
+      '{{#admin}}<button id="delete">x</button>{{/admin}}' +
+      '<button id="cancel">x</button>',
+    );
+    const matches = matchSelector(
+      tree.rootNode,
+      parseSelector('button:not({{#admin}} button)')!,
+    );
+    expect(matches).toHaveLength(1);
+    expect(matches[0].text).toContain('id="cancel"');
+  });
+
   // --- Chained :not() AND ---
 
   it('chained :not() AND together (EDC rule shape)', () => {

lsp/server/test/selectorMatcher.test.ts

@@ -24,7 +24,11 @@
  *     the outer compound), plus any other selector (including Mustache
  *     literals and type selectors) as a whole-selector check against the
  *     node itself. Example: `{{*}}:not({{internal.*}})` matches any
- *     interpolation whose path does not start with `internal.`.
+ *     interpolation whose path does not start with `internal.`. Multi-segment
+ *     selectors with combinators are supported and tested against the node's
+ *     ancestor/sibling context, matching `Element.matches` semantics — e.g.
+ *     `img:not(pl-overlay img)` matches any `img` that is not a descendant of
+ *     `pl-overlay`, and `td:not(thead td)` matches `td`s outside a `thead`.
  *   - `:root` — the tree-sitter fragment root (the whole document). Unlike
  *     browser CSS where `:root` matches `<html>`, this matches the parse-tree
  *     root so it works on partials/fragments too. Useful as a document-scoped
@@ -651,14 +655,25 @@ function hasDescendantMatch(node: BalanceNode, selector: ParsedSelector): boolea
   return false;
 }
 
-function checkSelfNegations(node: BalanceNode, negations: ParsedSelector[], rootNode: BalanceNode): boolean {
+function checkSelfNegations(
+  node: BalanceNode,
+  negations: ParsedSelector[],
+  rootNode: BalanceNode,
+  cursor: Cursor,
+): boolean {
   for (const sel of negations) {
     for (const alt of sel) {
-      // A selfNegation selector is a single-segment check against the node itself.
-      // Multi-segment alternatives (e.g. `:not(a b)`) aren't sensibly testable
-      // against a single node, so they're treated as never matching => pass.
-      if (alt.length !== 1) continue;
-      if (nodeMatchesSegment(node, alt[0], rootNode)) return false;
+      if (alt.length === 0) continue;
+      const lastSegment = alt[alt.length - 1];
+      if (!nodeMatchesSegment(node, lastSegment, rootNode, cursor)) continue;
+      if (alt.length === 1) return false;
+      // Multi-segment negation (e.g. `:not(ancestor descendant)`): the last
+      // segment matched the node itself; walk back through the remaining
+      // segments against the node's ancestor/sibling cursor. If the chain
+      // also matches, the negation fires.
+      if (checkPrefix(cursor, alt, alt.length - 2, lastSegment.combinator, rootNode)) {
+        return false;
+      }
     }
   }
   return true;
@@ -671,11 +686,16 @@ function matchesName(actual: string | null, segment: Segment): boolean {
   return actual === segment.name;
 }
 
-function nodeMatchesSegment(node: BalanceNode, segment: Segment, rootNode: BalanceNode): boolean {
+function nodeMatchesSegment(
+  node: BalanceNode,
+  segment: Segment,
+  rootNode: BalanceNode,
+  cursor: Cursor,
+): boolean {
   if (segment.rootOnly) {
     if (node !== rootNode) return false;
     return checkDescendants(node, segment.descendantChecks)
-        && checkSelfNegations(node, segment.selfNegations, rootNode);
+        && checkSelfNegations(node, segment.selfNegations, rootNode, cursor);
   }
   const baseMatches = (() => {
     switch (segment.kind) {
@@ -714,7 +734,7 @@ function nodeMatchesSegment(node: BalanceNode, segment: Segment, rootNode: Balan
     }
   })();
   if (!baseMatches) return false;
-  return checkSelfNegations(node, segment.selfNegations, rootNode);
+  return checkSelfNegations(node, segment.selfNegations, rootNode, cursor);
 }
 
 interface Cursor {
@@ -738,16 +758,16 @@ function checkPrefix(
     for (let i = cursor.indexInSiblings - 1; i >= 0; i--) {
       const sib = cursor.siblings[i];
       if (!isMatchableNode(sib)) continue;
-      if (!nodeMatchesSegment(sib, segment, rootNode)) {
-        if (stepCombinator === 'adjacent-sibling') return false;
-        continue;
-      }
-      const newCursor: Cursor = {
+      const sibCursor: Cursor = {
         ancestors: cursor.ancestors,
         siblings: cursor.siblings,
         indexInSiblings: i,
       };
-      if (checkPrefix(newCursor, segments, segIdx - 1, segment.combinator, rootNode)) return true;
+      if (!nodeMatchesSegment(sib, segment, rootNode, sibCursor)) {
+        if (stepCombinator === 'adjacent-sibling') return false;
+        continue;
+      }
+      if (checkPrefix(sibCursor, segments, segIdx - 1, segment.combinator, rootNode)) return true;
       if (stepCombinator === 'adjacent-sibling') return false;
     }
     return false;
@@ -770,13 +790,13 @@ function checkPrefix(
       if (!matchesName(entry.name, segment)) return false;
       if (segment.kind === 'html' && !checkAttributes(entry.node, segment.attributes)) return false;
       if (!checkDescendants(entry.node, segment.descendantChecks)) return false;
-      if (!checkSelfNegations(entry.node, segment.selfNegations, rootNode)) return false;
-      const newCursor: Cursor = {
+      const ancestorCursor: Cursor = {
         ancestors: cursor.ancestors.slice(0, a),
         siblings: entry.siblings,
         indexInSiblings: entry.indexInSiblings,
       };
-      return checkPrefix(newCursor, segments, segIdx - 1, segment.combinator, rootNode);
+      if (!checkSelfNegations(entry.node, segment.selfNegations, rootNode, ancestorCursor)) return false;
+      return checkPrefix(ancestorCursor, segments, segIdx - 1, segment.combinator, rootNode);
     }
     return false;
   }
@@ -787,13 +807,13 @@ function checkPrefix(
     if (!matchesName(entry.name, segment)) continue;
     if (segment.kind === 'html' && !checkAttributes(entry.node, segment.attributes)) continue;
     if (!checkDescendants(entry.node, segment.descendantChecks)) continue;
-    if (!checkSelfNegations(entry.node, segment.selfNegations, rootNode)) continue;
-    const newCursor: Cursor = {
+    const ancestorCursor: Cursor = {
       ancestors: cursor.ancestors.slice(0, a),
       siblings: entry.siblings,
       indexInSiblings: entry.indexInSiblings,
     };
-    if (checkPrefix(newCursor, segments, segIdx - 1, segment.combinator, rootNode)) return true;
+    if (!checkSelfNegations(entry.node, segment.selfNegations, rootNode, ancestorCursor)) continue;
+    if (checkPrefix(ancestorCursor, segments, segIdx - 1, segment.combinator, rootNode)) return true;
   }
   return false;
 }
@@ -862,8 +882,8 @@ function matchAlternative(
     siblings: BalanceNode[],
     indexInSiblings: number,
   ) {
-    if (nodeMatchesSegment(node, lastSegment, rootNode)) {
-      const cursor: Cursor = { ancestors, siblings, indexInSiblings };
+    const cursor: Cursor = { ancestors, siblings, indexInSiblings };
+    if (nodeMatchesSegment(node, lastSegment, rootNode, cursor)) {
       if (
         segments.length === 1 ||
         checkPrefix(cursor, segments, segments.length - 2, lastSegment.combinator, rootNode)