tree-sitter.ts

import * as LSP from 'vscode-languageserver/node'
import { SyntaxNode } from 'web-tree-sitter'

/**
 * Recursively iterate over all nodes in a tree.
 *
 * @param node The node to start iterating from
 * @param callback The callback to call for each node. Return false to stop following children.
 */
export function forEach(node: SyntaxNode, callback: (n: SyntaxNode) => void | boolean) {
  const followChildren = callback(node) !== false
  if (followChildren && node.children.length) {
    node.children.forEach((n) => forEach(n, callback))
  }
}

export function range(n: SyntaxNode): LSP.Range {
  return LSP.Range.create(
    n.startPosition.row,
    n.startPosition.column,
    n.endPosition.row,
    n.endPosition.column,
  )
}

export function isDefinition(n: SyntaxNode): boolean {
  switch (n.type) {
    case 'variable_assignment':
    case 'function_definition':
      return true
    default:
      return false
  }
}

export function isReference(n: SyntaxNode): boolean {
  switch (n.type) {
    case 'variable_name':
    case 'command_name':
      return true
    default:
      return false
  }
}

export function isVariableInReadCommand(n: SyntaxNode): boolean {
  if (
    n.type === 'word' &&
    n.parent?.type === 'command' &&
    n.parent.firstChild?.text === 'read' &&
    !n.text.startsWith('-') &&
    !/^-.*[dinNptu]$/.test(n.previousSibling?.text ?? '')
  ) {
    return true
  }

  return false
}

export function findParent(
  start: SyntaxNode,
  predicate: (n: SyntaxNode) => boolean,
): SyntaxNode | null {
  let node = start.parent
  while (node !== null) {
    if (predicate(node)) {
      return node
    }
    node = node.parent
  }
  return null
}

export function findParentOfType(start: SyntaxNode, type: string | string[]) {
  if (typeof type === 'string') {
    return findParent(start, (n) => n.type === type)
  }

  return findParent(start, (n) => type.includes(n.type))
}