Mapping a SyntaxNode Through Changes

blh · January 8, 2024, 11:29pm

I’m trying to write a command that asynchronously replaces (using effects) the corresponding range of a SyntaxNode in a document.

For example, with

=A1|

I would want to replace A1 with A2 on keyboard down, since A1 is parsed as a specific syntax node in my spreadsheet grammar.

Is there a way to check if a SyntaxNode is modified by a transaction, or is reused between two syntax trees?

I see that Lezer exports a NodeWeakMap but I’m not sure if that’s intended to be used along with CodeMirror.

github.com

lezer-parser/common/blob/6d094318fefa7a77ca59238ba96f5eac5813f519/src/tree.ts#L1650


      
                localPositions.push(groupStart + offset - start)
              }
            }
            divide(children, positions, from, to, 0)
            return (mkTop || mkTree)(localChildren, localPositions, length)
          }
          
          /// Provides a way to associate values with pieces of trees. As long
          /// as that part of the tree is reused, the associated values can be
          /// retrieved from an updated tree.
          export class NodeWeakMap<T> {
            private map = new WeakMap<Tree | TreeBuffer, T | Map<number, T>>()
          
            private setBuffer(buffer: TreeBuffer, index: number, value: T) {
              let inner = this.map.get(buffer) as Map<number, T> | undefined
              if (!inner) this.map.set(buffer, inner = new Map)
              inner.set(index, value)
            }
          
            private getBuffer(buffer: TreeBuffer, index: number): T | undefined {
              let inner = this.map.get(buffer) as Map<number, T> | undefined

Normally, if I were to asynchronously replace a range, I would probably keep a {from, to} tuple and map it through the transaction, checking if either positions were deleted.

marijn · January 8, 2024, 11:43pm

Reuse between trees is probably not the check you’re looking for here—nearby changes can cause nodes to be reallocated even if they themselves aren’t touched. Maybe just check if any intermediate change touched the node’s range, and, if that’s important, that it’s still parsed the same way in the current syntax tree (i.e. that it wasn’t commented out or quoted).

blh · January 9, 2024, 12:07am

nearby changes can cause nodes to be reallocated even if they themselves aren’t touched

Ah, that’s good to know about the reference stability of a SyntaxNode. I will probably write some type of heuristic to check if a range has an approximately equivalent SyntaxNode in between trees.

Thanks!