Don't discard nodes with non adjacent error siblings (#2860)

Today we discard parse tree nodes if any of the ancestral nodes has a
error. That means that any of the ancestral nodes has a descendant that
is an error node. That could be something a hundred lines below that
isn't really relevant to the node we are evaluating. This updates
changes so we only look at error nodes that are adjacent to our
ascending path.

Author: AndreasArvidsson

data/fixtures/recorded/surroundingPair/changePair.yml

@@ -0,0 +1,25 @@
+languageId: typescriptreact
+command:
+  version: 7
+  spokenForm: change pair
+  action:
+    name: clearAndSetSelection
+    target:
+      type: primitive
+      modifiers:
+        - type: containingScope
+          scopeType: {type: surroundingPair, delimiter: any}
+  usePrePhraseSnapshot: false
+initialState:
+  documentContents: |
+    <div bbb={() => null}>hello &</div>
+  selections:
+    - anchor: {line: 0, character: 14}
+      active: {line: 0, character: 14}
+  marks: {}
+finalState:
+  documentContents: |
+    <div bbb=>hello &</div>
+  selections:
+    - anchor: {line: 0, character: 9}
+      active: {line: 0, character: 9}

packages/cursorless-engine/src/languages/TreeSitterQuery/isContainedInErrorNode.ts

@@ -6,13 +6,35 @@ import type { SyntaxNode } from "web-tree-sitter";
  * @returns True if the given node is contained in an error node
  */
 export function isContainedInErrorNode(node: SyntaxNode) {
-  let currentNode: SyntaxNode | null = node;
+  // This node or one of it descendants is an error node
+  if (node.hasError) {
+    return true;
+  }
+
+  let ancestorNode: SyntaxNode | null = node.parent;
+
+  while (ancestorNode != null) {
+    // Ancestral node is an error node
+    if (ancestorNode.isError) {
+      return true;
+    }
+
+    // Ancestral node has errors, but it was not siblings to the previous node.
+    // We don't want to discard a node when a sibling that isn't adjacent is
+    // erroring.
+    if (ancestorNode.hasError) {
+      return false;
+    }
 
-  while (currentNode != null) {
-    if (currentNode.hasError) {
+    // A adjacent sibling node was causing the problem. ie we are right next to the error node.
+    if (
+      ancestorNode.previousSibling?.isError ||
+      ancestorNode.nextSibling?.isError
+    ) {
       return true;
     }
-    currentNode = currentNode.parent;
+
+    ancestorNode = ancestorNode.parent;
   }
 
   return false;