neovim/runtime/doc/treesitter.txt

*treesitter.txt*    Nvim


                            NVIM REFERENCE MANUAL


Treesitter integration                                 *treesitter*

Nvim integrates the `tree-sitter` library for incremental parsing of buffers:
https://tree-sitter.github.io/tree-sitter/

WARNING: Treesitter support is still experimental and subject to frequent
changes. This documentation may also not fully reflect the latest changes.

                                      Type |gO| to see the table of contents.

==============================================================================
PARSER FILES                                              *treesitter-parsers*

Parsers are the heart of treesitter. They are libraries that treesitter will
search for in the `parser` runtime directory.

Nvim includes these parsers:

- Bash
- C
- Lua
- Markdown
- Python
- Vimscript
- Vimdoc
- Treesitter query files |ft-query-plugin|

You can install more parsers manually, or with a plugin like
https://github.com/nvim-treesitter/nvim-treesitter .

Parsers are searched for as `parser/{lang}.*` in any 'runtimepath' directory.
If multiple parsers for the same language are found, the first one is used.
(NOTE: This typically implies the priority "user config > plugins > bundled".)

To load a parser from its filepath: >lua

    vim.treesitter.language.add('python', { path = "/path/to/python.so" })
<
Parser names are assumed to be lower case if the file system is
case-sensitive.

To associate certain |filetypes| with a treesitter language (name of parser),
use |vim.treesitter.language.register()|. For example, to use the `xml`
treesitter parser for buffers with filetype `svg` or `xslt`, use: >lua

    vim.treesitter.language.register('xml', { 'svg', 'xslt' })
<

==============================================================================
TREESITTER TREES                                             *treesitter-tree*
                                                                      *TSTree*

A "treesitter tree" represents the parsed contents of a buffer, which can be
used to perform further analysis. It is a |userdata| reference to an object
held by the treesitter library.

An instance `TSTree` of a treesitter tree supports the following methods.

TSTree:root()                                           *TSTree:root()*
    Return the root node of this tree.

TSTree:copy()                                           *TSTree:copy()*
    Returns a copy of the `TSTree`.

==============================================================================
TREESITTER NODES                                             *treesitter-node*
                                                                      *TSNode*

A "treesitter node" represents one specific element of the parsed contents of
a buffer, which can be captured by a |Query| for, e.g., highlighting. It is
a |userdata| reference to an object held by the treesitter library.

An instance `TSNode` of a treesitter node supports the following methods.

TSNode:parent()                                         *TSNode:parent()*
    Get the node's immediate parent.

TSNode:next_sibling()                                   *TSNode:next_sibling()*
    Get the node's next sibling.

TSNode:prev_sibling()                                   *TSNode:prev_sibling()*
    Get the node's previous sibling.

TSNode:next_named_sibling()                       *TSNode:next_named_sibling()*
    Get the node's next named sibling.

TSNode:prev_named_sibling()                       *TSNode:prev_named_sibling()*
    Get the node's previous named sibling.

TSNode:iter_children()                                 *TSNode:iter_children()*
    Iterates over all the direct children of {TSNode}, regardless of whether
    they are named or not.
    Returns the child node plus the eventual field name corresponding to this
    child node.

TSNode:field({name})                                    *TSNode:field()*
    Returns a table of the nodes corresponding to the {name} field.

TSNode:child_count()                                    *TSNode:child_count()*
    Get the node's number of children.

TSNode:child({index})                                   *TSNode:child()*
    Get the node's child at the given {index}, where zero represents the first
    child.

TSNode:named_child_count()                         *TSNode:named_child_count()*
    Get the node's number of named children.

TSNode:named_child({index})                              *TSNode:named_child()*
    Get the node's named child at the given {index}, where zero represents the
    first named child.

TSNode:start()                                          *TSNode:start()*
    Get the node's start position. Return three values: the row, column and
    total byte count (all zero-based).

TSNode:end_()                                           *TSNode:end_()*
    Get the node's end position. Return three values: the row, column and
    total byte count (all zero-based).

TSNode:range({include_bytes})                           *TSNode:range()*
    Get the range of the node.

    Return four or six values:
        - start row
        - start column
        - start byte (if {include_bytes} is `true`)
        - end row
        - end column
        - end byte (if {include_bytes} is `true`)

TSNode:type()                                           *TSNode:type()*
    Get the node's type as a string.

TSNode:symbol()                                         *TSNode:symbol()*
    Get the node's type as a numerical id.

TSNode:named()                                          *TSNode:named()*
    Check if the node is named. Named nodes correspond to named rules in the
    grammar, whereas anonymous nodes correspond to string literals in the
    grammar.

TSNode:missing()                                        *TSNode:missing()*
    Check if the node is missing. Missing nodes are inserted by the parser in
    order to recover from certain kinds of syntax errors.

TSNode:extra()                                          *TSNode:extra()*
    Check if the node is extra. Extra nodes represent things like comments,
    which are not required by the grammar but can appear anywhere.

TSNode:has_changes()                                    *TSNode:has_changes()*
    Check if a syntax node has been edited.

TSNode:has_error()                                      *TSNode:has_error()*
    Check if the node is a syntax error or contains any syntax errors.

TSNode:sexpr()                                          *TSNode:sexpr()*
    Get an S-expression representing the node as a string.

TSNode:id()                                             *TSNode:id()*
    Get a unique identifier for the node inside its own tree.

    No guarantees are made about this identifier's internal representation,
    except for being a primitive Lua type with value equality (so not a
    table). Presently it is a (non-printable) string.

    Note: The `id` is not guaranteed to be unique for nodes from different
    trees.

TSNode:tree()                                           *TSNode:tree()*
    Get the |TSTree| of the node.
                                                *TSNode:descendant_for_range()*
TSNode:descendant_for_range({start_row}, {start_col}, {end_row}, {end_col})
    Get the smallest node within this node that spans the given range of (row,
    column) positions

                                          *TSNode:named_descendant_for_range()*
TSNode:named_descendant_for_range({start_row}, {start_col}, {end_row}, {end_col})
    Get the smallest named node within this node that spans the given range of
    (row, column) positions
                                                        *TSNode:equal()*
TSNode:equal({node})
    Check if {node} refers to the same node within the same tree.

                                                        *TSNode:byte_length()*
TSNode:byte_length()
    Return the number of bytes spanned by this node.

==============================================================================
TREESITTER QUERIES                                          *treesitter-query*

Treesitter queries are a way to extract information about a parsed |TSTree|,
e.g., for the purpose of highlighting. Briefly, a `query` consists of one or
more patterns. A `pattern` is defined over node types in the syntax tree. A
`match` corresponds to specific elements of the syntax tree which match a
pattern. Patterns may optionally define captures and predicates. A `capture`
allows you to associate names with a specific node in a pattern. A `predicate`
adds arbitrary metadata and conditional data to a match.

Queries are written in a lisp-like language documented in
https://tree-sitter.github.io/tree-sitter/using-parsers#query-syntax
Note: The predicates listed there page differ from those Nvim supports. See
|treesitter-predicates| for a complete list of predicates supported by Nvim.

Nvim looks for queries as `*.scm` files in a `queries` directory under
`runtimepath`, where each file contains queries for a specific language and
purpose, e.g., `queries/lua/highlights.scm` for highlighting Lua files.
By default, the first query on `runtimepath` is used (which usually implies
that user config takes precedence over plugins, which take precedence over
queries bundled with Nvim). If a query should extend other queries instead
of replacing them, use |treesitter-query-modeline-extends|.

See |lua-treesitter-query| for the list of available methods for working with
treesitter queries from Lua.


TREESITTER QUERY PREDICATES                            *treesitter-predicates*

Predicates are special scheme nodes that are evaluated to conditionally capture
nodes. For example, the `eq?` predicate can be used as follows: >query

    ((identifier) @variable.builtin
      (#eq? @variable.builtin "self"))
<
to only match identifier corresponding to the `"self"` text. Such queries can
be used to highlight built-in functions or variables differently, for instance.

The following predicates are built in:

    `eq?`                                            *treesitter-predicate-eq?*
        Match a string against the text corresponding to a node: >query
            ((identifier) @variable.builtin (#eq? @variable.builtin "self"))
            ((node1) @left (node2) @right (#eq? @left @right))
<
    `any-eq?`                                    *treesitter-predicate-any-eq?*
        Like `eq?`, but for quantified patterns only one captured node must
        match.

    `match?`                                      *treesitter-predicate-match?*
    `vim-match?`                              *treesitter-predicate-vim-match?*
         Match a |regexp| against the text corresponding to a node: >query
            ((identifier) @constant (#match? @constant "^[A-Z_]+$"))
<
         Note: The `^` and `$` anchors will match the start and end of the
               node's text.

    `any-match?`                              *treesitter-predicate-any-match?*
    `any-vim-match?`                      *treesitter-predicate-any-vim-match?*
        Like `match?`, but for quantified patterns only one captured node must
        match.

    `lua-match?`                              *treesitter-predicate-lua-match?*
         Match |lua-patterns| against the text corresponding to a node,
         similar to `match?`

    `any-lua-match?`                      *treesitter-predicate-any-lua-match?*
         Like `lua-match?`, but for quantified patterns only one captured node
         must match.

    `contains?`                                *treesitter-predicate-contains?*
        Match a string against parts of the text corresponding to a node: >query
            ((identifier) @foo (#contains? @foo "foo"))
            ((identifier) @foo-bar (#contains? @foo-bar "foo" "bar"))
<
    `any-contains?`                        *treesitter-predicate-any-contains?*
        Like `contains?`, but for quantified patterns only one captured node
        must match.

    `any-of?`                                    *treesitter-predicate-any-of?*
        Match any of the given strings against the text corresponding to
        a node: >query
            ((identifier) @foo (#any-of? @foo "foo" "bar"))
<
        This is the recommended way to check if the node matches one of many
        keywords, as it has been optimized for this.

    `has-ancestor?`                        *treesitter-predicate-has-ancestor?*
        Match any of the given node types against all ancestors of a node: >query
            ((identifier) @variable.builtin
              (#any-of? @variable.builtin "begin" "end")
              (#has-ancestor? @variable.builtin range_expression))
<
    `has-parent?`                            *treesitter-predicate-has-parent?*
        Match any of the given node types against the direct ancestor of a
        node: >query
            (((field_expression
                 (field_identifier) @method)) @_parent
             (#has-parent? @_parent template_method function_declarator))
<
                                                 *lua-treesitter-not-predicate*
Each predicate has a `not-` prefixed predicate that is just the negation of
the predicate.

                                                 *lua-treesitter-all-predicate*
                                                 *lua-treesitter-any-predicate*
Queries can use quantifiers to capture multiple nodes. When a capture contains
multiple nodes, predicates match only if ALL nodes contained by the capture
match the predicate. Some predicates (`eq?`, `match?`, `lua-match?`,
`contains?`) accept an `any-` prefix to instead match if ANY of the nodes
contained by the capture match the predicate.

As an example, consider the following Lua code: >lua

  -- TODO: This is a
  -- very long
  -- comment (just imagine it)
<
using the following predicated query:
>query
    (((comment)+ @comment)
     (#match? @comment "TODO"))
<
This query will not match because not all of the nodes captured by @comment
match the predicate. Instead, use:
>query
    (((comment)+ @comment)
     (#any-match? @comment "TODO"))
<

Further predicates can be added via |vim.treesitter.query.add_predicate()|.
Use |vim.treesitter.query.list_predicates()| to list all available predicates.


TREESITTER QUERY DIRECTIVES                            *treesitter-directives*

Treesitter directives store metadata for a node or match and perform side
effects. For example, the `set!` directive sets metadata on the match or node: >query

        ((identifier) @foo (#set! type "parameter"))
<
The following directives are built in:

    `set!`                                          *treesitter-directive-set!*
        Sets key/value metadata for a specific match or capture. Value is
        accessible as either `metadata[key]` (match specific) or
        `metadata[capture_id][key]` (capture specific).

        Parameters: ~
            {capture_id} (optional)
            {key}
            {value}

        Examples: >query
            ((identifier) @foo (#set! @foo kind "parameter"))
            ((node1) @left (node2) @right (#set! type "pair"))
            ((codeblock) @markup.raw.block (#set! priority 90))
<
    `offset!`                                      *treesitter-directive-offset!*
        Takes the range of the captured node and applies an offset. This will
        set a new `Range4` object for the captured node with `capture_id` as
        `metadata[capture_id].range`. Useful for |treesitter-language-injections|.

        Parameters: ~
            {capture_id}
            {start_row}
            {start_col}
            {end_row}
            {end_col}

        Example: >query
            ((identifier) @constant (#offset! @constant 0 1 0 -1))
<
    `gsub!`                                          *treesitter-directive-gsub!*
        Transforms the content of the node using a |lua-pattern|. This will set
        a new `metadata[capture_id].text`.

        Parameters: ~
            {capture_id}
            {pattern}
            {replacement}

        Example: >query
            (#gsub! @_node ".*%.(.*)" "%1")
<
    `trim!`                                          *treesitter-directive-trim!*
        Trim blank lines from the end of the node. This will set a new
        `metadata[capture_id].range`.

        Parameters: ~
            {capture_id}

        Example: >query
            (#trim! @fold)
<
Further directives can be added via |vim.treesitter.query.add_directive()|.
Use |vim.treesitter.query.list_directives()| to list all available directives.


TREESITTER QUERY MODELINES                          *treesitter-query-modeline*

Nvim supports to customize the behavior of the queries using a set of
"modelines", that is comments in the queries starting with `;`. Here are the
currently supported modeline alternatives:

    `inherits: {lang}...`                     *treesitter-query-modeline-inherits*
        Specifies that this query should inherit the queries from {lang}.
        This will recursively descend in the queries of {lang} unless wrapped
        in parentheses: `({lang})`.
        Note: This is meant to be used to include queries from another
        language. If you want your query to extend the queries of the same
        language, use `extends`.

    `extends`                                  *treesitter-query-modeline-extends*
        Specifies that this query should be used as an extension for the
        query, i.e. that it should be merged with the others.
        Note: The order of the extensions, and the query that will be used as
        a base depends on your 'runtimepath' value.

Note: These modeline comments must be at the top of the query, but can be
repeated, for example, the following two modeline blocks are both valid:
>query
    ;; inherits: typescript,jsx
    ;; extends
<
>query
    ;; extends
    ;;
    ;; inherits: css
<
==============================================================================
TREESITTER SYNTAX HIGHLIGHTING                          *treesitter-highlight*

Syntax highlighting is specified through queries named `highlights.scm`,
which match a |TSNode| in the parsed |TSTree| to a `capture` that can be
assigned a highlight group. For example, the query >query

    (parameters (identifier) @variable.parameter)
<
matches any `identifier` node inside a function `parameters` node to the
capture named `@variable.parameter`. For example, for a Lua code >lua

    function f(foo, bar) end
<
which will be parsed as (see |:InspectTree|): >query

    (function_declaration ; [1:1 - 24]
      name: (identifier) ; [1:10 - 10]
      parameters: (parameters ; [1:11 - 20]
        name: (identifier) ; [1:12 - 14]
        name: (identifier))) ; [1:17 - 19]
<
the above query will highlight `foo` and `bar` as `@variable.parameter`.

It is also possible to match literal expressions (provided the parser returns
them):
>query
    [
      "if"
      "else"
    ] @keyword.conditional
<
Assuming a suitable parser and `highlights.scm` query is found in runtimepath,
treesitter highlighting for the current buffer can be enabled simply via
|vim.treesitter.start()|.

                                                 *treesitter-highlight-groups*
The capture names, prefixed with `@`, are directly usable as highlight groups.
For many commonly used captures, the corresponding highlight groups are linked
to Nvim's standard |highlight-groups| by default (e.g., `@comment` links to
`Comment`) but can be overridden in colorschemes.

A fallback system is implemented, so that more specific groups fallback to
more generic ones. For instance, in a language that has separate doc comments
(e.g., c, java, etc.), `@comment.documentation` could be used. If this group
is not defined, the highlighting for an ordinary `@comment` is used. This way,
existing color schemes already work out of the box, but it is possible to add
more specific variants for queries that make them available.

As an additional rule, capture highlights can always be specialized by
language, by appending the language name after an additional dot. For
instance, to highlight comments differently per language: >vim

    hi @comment.c guifg=Blue
    hi @comment.lua guifg=DarkBlue
    hi link @comment.documentation.java String
<
The following is a list of standard captures used in queries for Nvim,
highlighted according to the current colorscheme (use |:Inspect| on one to see
the exact definition):

@variable                       various variable names
@variable.builtin               built-in variable names (e.g. `this`, `self`)
@variable.parameter             parameters of a function
@variable.parameter.builtin     special parameters (e.g. `_`, `it`)
@variable.member                object and struct fields

@constant               constant identifiers
@constant.builtin       built-in constant values
@constant.macro         constants defined by the preprocessor

@module                 modules or namespaces
@module.builtin         built-in modules or namespaces
@label                  `GOTO` and other labels (e.g. `label:` in C), including heredoc labels

@string                 string literals
@string.documentation   string documenting code (e.g. Python docstrings)
@string.regexp          regular expressions
@string.escape          escape sequences
@string.special         other special strings (e.g. dates)
@string.special.symbol  symbols or atoms
@string.special.path    filenames
@string.special.url     URIs (e.g. hyperlinks)

@character              character literals
@character.special      special characters (e.g. wildcards)

@boolean                boolean literals
@number                 numeric literals
@number.float           floating-point number literals

@type                   type or class definitions and annotations
@type.builtin           built-in types
@type.definition        identifiers in type definitions (e.g. `typedef <type> <identifier>` in C)

@attribute              attribute annotations (e.g. Python decorators, Rust lifetimes)
@attribute.builtin      builtin annotations (e.g. `@property` in Python)
@property               the key in key/value pairs

@function               function definitions
@function.builtin       built-in functions
@function.call          function calls
@function.macro         preprocessor macros

@function.method        method definitions
@function.method.call   method calls

@constructor            constructor calls and definitions
@operator               symbolic operators (e.g. `+`, `*`)

@keyword                keywords not fitting into specific categories
@keyword.coroutine      keywords related to coroutines (e.g. `go` in Go, `async/await` in Python)
@keyword.function       keywords that define a function (e.g. `func` in Go, `def` in Python)
@keyword.operator       operators that are English words (e.g. `and`, `or`)
@keyword.import         keywords for including modules (e.g. `import`, `from` in Python)
@keyword.type           keywords defining composite types (e.g. `struct`, `enum`)
@keyword.modifier       keywords defining type modifiers (e.g. `const`, `static`, `public`)
@keyword.repeat         keywords related to loops (e.g. `for`, `while`)
@keyword.return         keywords like `return` and `yield`
@keyword.debug          keywords related to debugging
@keyword.exception      keywords related to exceptions (e.g. `throw`, `catch`)

@keyword.conditional         keywords related to conditionals (e.g. `if`, `else`)
@keyword.conditional.ternary ternary operator (e.g. `?`, `:`)

@keyword.directive           various preprocessor directives and shebangs
@keyword.directive.define    preprocessor definition directives

@punctuation.delimiter  delimiters (e.g. `;`, `.`, `,`)
@punctuation.bracket    brackets (e.g. `()`, `{}`, `[]`)
@punctuation.special    special symbols (e.g. `{}` in string interpolation)

@comment                line and block comments
@comment.documentation  comments documenting code

@comment.error          error-type comments (e.g. `ERROR`, `FIXME`, `DEPRECATED`)
@comment.warning        warning-type comments (e.g. `WARNING`, `FIX`, `HACK`)
@comment.todo           todo-type comments (e.g. `TODO`, `WIP`)
@comment.note           note-type comments (e.g. `NOTE`, `INFO`, `XXX`)

@markup.strong          bold text
@markup.italic          italic text
@markup.strikethrough   struck-through text
@markup.underline       underlined text (only for literal underline markup!)

@markup.heading         headings, titles (including markers)
@markup.heading.1       top-level heading
@markup.heading.2       section heading
@markup.heading.3       subsection heading
@markup.heading.4       and so on
@markup.heading.5       and so forth
@markup.heading.6       six levels ought to be enough for anybody

@markup.quote           block quotes
@markup.math            math environments (e.g. `$ ... $` in LaTeX)

@markup.link            text references, footnotes, citations, etc.
@markup.link.label      link, reference descriptions
@markup.link.url        URL-style links

@markup.raw             literal or verbatim text (e.g. inline code)
@markup.raw.block       literal or verbatim text as a stand-alone block

@markup.list            list markers
@markup.list.checked    checked todo-style list markers
@markup.list.unchecked  unchecked todo-style list markers

@diff.plus              added text (for diff files)
@diff.minus             deleted text (for diff files)
@diff.delta             changed text (for diff files)

@tag                    XML-style tag names (e.g. in XML, HTML, etc.)
@tag.builtin            XML-style tag names (e.g. HTML5 tags)
@tag.attribute          XML-style tag attributes
@tag.delimiter          XML-style tag delimiters

                                                  *treesitter-highlight-spell*
The special `@spell` capture can be used to indicate that a node should be
spell checked by Nvim's builtin |spell| checker. For example, the following
capture marks comments as to be checked: >query

    (comment) @spell
<

There is also `@nospell` which disables spellchecking regions with `@spell`.

                                                *treesitter-highlight-conceal*
Treesitter highlighting supports |conceal| via the `conceal` metadata. By
convention, nodes to be concealed are captured as `@conceal`, but any capture
can be used. For example, the following query can be used to hide code block
delimiters in Markdown: >query

    (fenced_code_block_delimiter @conceal (#set! conceal ""))
<
It is also possible to replace a node with a single character, which (unlike
legacy syntax) can be given a custom highlight. For example, the following
(ill-advised) query replaces the `!=` operator by a Unicode glyph, which is
still highlighted the same as other operators: >query

    "!=" @operator (#set! conceal "≠")
<
Conceals specified in this way respect 'conceallevel'.

                                               *treesitter-highlight-priority*
Treesitter uses |nvim_buf_set_extmark()| to set highlights with a default
priority of 100. This enables plugins to set a highlighting priority lower or
higher than treesitter. It is also possible to change the priority of an
individual query pattern manually by setting its `"priority"` metadata
attribute: >query

    ((super_important_node) @superimportant (#set! priority 105))
<

==============================================================================
TREESITTER LANGUAGE INJECTIONS                *treesitter-language-injections*
<

Note the following information is adapted from:
  https://tree-sitter.github.io/tree-sitter/syntax-highlighting#language-injection

Some source files contain code written in multiple different languages.
Examples include:

    • HTML files, which can contain JavaScript inside of `<script>` tags and
      CSS inside of `<style>` tags
    • ERB files, which contain Ruby inside of `<%` `%>` tags, and HTML outside of
      those tags
    • PHP files, which can contain HTML between the `<php` tags
    • JavaScript files, which contain regular expression syntax within regex
      literals
    • Ruby, which can contain snippets of code inside of heredoc literals,
      where the heredoc delimiter often indicates the language
    • Lua, which can contain snippets of Vimscript inside |vim.cmd()| calls.
    • Vimscript, which can contain snippets of Lua inside |:lua-heredoc|
      blocks.

All of these examples can be modeled in terms of a parent syntax tree and one
or more injected syntax trees, which reside inside of certain nodes in the
parent tree. The language injection query allows you to specify these
“injections” using the following captures:

    • `@injection.content` - indicates that the captured node should have its
      contents re-parsed using another language.
    • `@injection.language` - indicates that the captured node’s text may
      contain the name of a language that should be used to re-parse the
      `@injection.content`.
    • `@injection.filename` - indicates that the captured node’s text may
      contain a filename; the corresponding filetype is then looked-up up via
      |vim.filetype.match()| and treated as the name of a language that should
      be used to re-parse the `@injection.content`.

The language injection behavior can also be configured by some properties
associated with patterns:

    • `injection.language` - can be used to hard-code the name of a specific
    language.
    • `injection.combined` - indicates that all of the matching nodes in the
    tree should have their content parsed as one nested document.
    • `injection.include-children` - indicates that the `@injection.content`
    node's entire text should be re-parsed, including the text of its child
    nodes. By default, child nodes' text will be excluded from the injected
    document.
    • `injection.self` - indicates that the node's text should be parsed with
      the same language as the node's LanguageTree.
    • `injection.parent` - indicates that the captured node’s text should
      be parsed with the same language as the node's parent LanguageTree.

==============================================================================
VIM.TREESITTER                                                *lua-treesitter*

The remainder of this document is a reference manual for the `vim.treesitter`
Lua module, which is the main interface for Nvim's treesitter integration.
Most of the following content is automatically generated from the function
documentation.


                                             *vim.treesitter.language_version*
The latest parser ABI version that is supported by the bundled treesitter
library.

                                     *vim.treesitter.minimum_language_version*
The earliest parser ABI version that is supported by the bundled treesitter
library.

==============================================================================
Lua module: vim.treesitter                               *lua-treesitter-core*

foldexpr({lnum})                                   *vim.treesitter.foldexpr()*
    Returns the fold level for {lnum} in the current buffer. Can be set
    directly to 'foldexpr': >lua
        vim.wo.foldexpr = 'v:lua.vim.treesitter.foldexpr()'
<

    Parameters: ~
      • {lnum}  (`integer?`) Line number to calculate fold level for

    Return: ~
        (`string`)

                                     *vim.treesitter.get_captures_at_cursor()*
get_captures_at_cursor({winnr})
    Returns a list of highlight capture names under the cursor

    Parameters: ~
      • {winnr}  (`integer?`) Window handle or 0 for current window (default)

    Return: ~
        (`string[]`) List of capture names

                                        *vim.treesitter.get_captures_at_pos()*
get_captures_at_pos({bufnr}, {row}, {col})
    Returns a list of highlight captures at the given position

    Each capture is represented by a table containing the capture name as a
    string as well as a table of metadata (`priority`, `conceal`, ...; empty
    if none are defined).

    Parameters: ~
      • {bufnr}  (`integer`) Buffer number (0 for current buffer)
      • {row}    (`integer`) Position row
      • {col}    (`integer`) Position column

    Return: ~
        (`{capture: string, lang: string, metadata: table}[]`)

get_node({opts})                                   *vim.treesitter.get_node()*
    Returns the smallest named node at the given position

    NOTE: Calling this on an unparsed tree can yield an invalid node. If the
    tree is not known to be parsed by, e.g., an active highlighter, parse the
    tree first via >lua
        vim.treesitter.get_parser(bufnr):parse(range)
<

    Parameters: ~
      • {opts}  (`table?`) Optional keyword arguments:
                • {bufnr} (`integer?`) Buffer number (nil or 0 for current
                  buffer)
                • {pos} (`{ [1]: integer, [2]: integer }?`) 0-indexed (row,
                  col) tuple. Defaults to cursor position in the current
                  window. Required if {bufnr} is not the current buffer
                • {lang} (`string?`) Parser language. (default: from buffer
                  filetype)
                • {ignore_injections} (`boolean?`) Ignore injected languages
                  (default true)

    Return: ~
        (`TSNode?`) Node at the given position

get_node_range({node_or_range})              *vim.treesitter.get_node_range()*
    Returns the node's range or an unpacked range table

    Parameters: ~
      • {node_or_range}  (`TSNode|table`) Node or table of positions

    Return (multiple): ~
        (`integer`) start_row
        (`integer`) start_col
        (`integer`) end_row
        (`integer`) end_col

                                              *vim.treesitter.get_node_text()*
get_node_text({node}, {source}, {opts})
    Gets the text corresponding to a given node

    Parameters: ~
      • {node}    (`TSNode`)
      • {source}  (`integer|string`) Buffer or string from which the {node} is
                  extracted
      • {opts}    (`table?`) Optional parameters.
                  • metadata (table) Metadata of a specific capture. This
                    would be set to `metadata[capture_id]` when using
                    |vim.treesitter.query.add_directive()|.

    Return: ~
        (`string`)

get_parser({bufnr}, {lang}, {opts})              *vim.treesitter.get_parser()*
    Returns the parser for a specific buffer and attaches it to the buffer

    If needed, this will create the parser.

    Parameters: ~
      • {bufnr}  (`integer?`) Buffer the parser should be tied to (default:
                 current buffer)
      • {lang}   (`string?`) Language of this parser (default: from buffer
                 filetype)
      • {opts}   (`table?`) Options to pass to the created language tree

    Return: ~
        (`vim.treesitter.LanguageTree`) object to use for parsing

get_range({node}, {source}, {metadata})           *vim.treesitter.get_range()*
    Get the range of a |TSNode|. Can also supply {source} and {metadata} to
    get the range with directives applied.

    Parameters: ~
      • {node}      (`TSNode`)
      • {source}    (`integer|string?`) Buffer or string from which the {node}
                    is extracted
      • {metadata}  (`vim.treesitter.query.TSMetadata?`)

    Return: ~
        (`Range6`)

                                          *vim.treesitter.get_string_parser()*
get_string_parser({str}, {lang}, {opts})
    Returns a string parser

    Parameters: ~
      • {str}   (`string`) Text to parse
      • {lang}  (`string`) Language of this string
      • {opts}  (`table?`) Options to pass to the created language tree

    Return: ~
        (`vim.treesitter.LanguageTree`) object to use for parsing

inspect_tree({opts})                           *vim.treesitter.inspect_tree()*
    Open a window that displays a textual representation of the nodes in the
    language tree.

    While in the window, press "a" to toggle display of anonymous nodes, "I"
    to toggle the display of the source language of each node, "o" to toggle
    the query editor, and press <Enter> to jump to the node under the cursor
    in the source buffer. Folding also works (try |zo|, |zc|, etc.).

    Can also be shown with `:InspectTree`.                      *:InspectTree*

    Parameters: ~
      • {opts}  (`table?`) Optional options table with the following possible
                keys:
                • lang (string|nil): The language of the source buffer. If
                  omitted, detect from the filetype of the source buffer.
                • bufnr (integer|nil): Buffer to draw the tree into. If
                  omitted, a new buffer is created.
                • winid (integer|nil): Window id to display the tree buffer
                  in. If omitted, a new window is created with {command}.
                • command (string|nil): Vimscript command to create the
                  window. Default value is "60vnew". Only used when {winid} is
                  nil.
                • title (string|fun(bufnr:integer):string|nil): Title of the
                  window. If a function, it accepts the buffer number of the
                  source buffer as its only argument and should return a
                  string.

is_ancestor({dest}, {source})                   *vim.treesitter.is_ancestor()*
    Determines whether a node is the ancestor of another

    Parameters: ~
      • {dest}    (`TSNode`) Possible ancestor
      • {source}  (`TSNode`) Possible descendant

    Return: ~
        (`boolean`) True if {dest} is an ancestor of {source}

                                           *vim.treesitter.is_in_node_range()*
is_in_node_range({node}, {line}, {col})
    Determines whether (line, col) position is in node range

    Parameters: ~
      • {node}  (`TSNode`) defining the range
      • {line}  (`integer`) Line (0-based)
      • {col}   (`integer`) Column (0-based)

    Return: ~
        (`boolean`) True if the position is in node range

node_contains({node}, {range})                *vim.treesitter.node_contains()*
    Determines if a node contains a range

    Parameters: ~
      • {node}   (`TSNode`)
      • {range}  (`table`)

    Return: ~
        (`boolean`) True if the {node} contains the {range}

start({bufnr}, {lang})                                *vim.treesitter.start()*
    Starts treesitter highlighting for a buffer

    Can be used in an ftplugin or FileType autocommand.

    Note: By default, disables regex syntax highlighting, which may be
    required for some plugins. In this case, add `vim.bo.syntax = 'on'` after
    the call to `start`.

    Example: >lua
        vim.api.nvim_create_autocmd( 'FileType', { pattern = 'tex',
            callback = function(args)
                vim.treesitter.start(args.buf, 'latex')
                vim.bo[args.buf].syntax = 'on'  -- only if additional legacy syntax is needed
            end
        })
<

    Parameters: ~
      • {bufnr}  (`integer?`) Buffer to be highlighted (default: current
                 buffer)
      • {lang}   (`string?`) Language of the parser (default: from buffer
                 filetype)

stop({bufnr})                                          *vim.treesitter.stop()*
    Stops treesitter highlighting for a buffer

    Parameters: ~
      • {bufnr}  (`integer?`) Buffer to stop highlighting (default: current
                 buffer)


==============================================================================
Lua module: vim.treesitter.language                  *lua-treesitter-language*

add({lang}, {opts})                            *vim.treesitter.language.add()*
    Load parser with name {lang}

    Parsers are searched in the `parser` runtime directory, or the provided
    {path}

    Parameters: ~
      • {lang}  (`string`) Name of the parser (alphanumerical and `_` only)
      • {opts}  (`table?`) Options:
                • {filetype}? (`string|string[]`, default: {lang}) Default
                  filetype the parser should be associated with.
                • {path}? (`string`) Optional path the parser is located at
                • {symbol_name}? (`string`) Internal symbol name for the
                  language to load

get_filetypes({lang})                *vim.treesitter.language.get_filetypes()*
    Get the filetypes associated with the parser named {lang}.

    Parameters: ~
      • {lang}  (`string`) Name of parser

    Return: ~
        (`string[]`) filetypes

get_lang({filetype})                      *vim.treesitter.language.get_lang()*

    Parameters: ~
      • {filetype}  (`string`)

    Return: ~
        (`string?`)

inspect({lang})                            *vim.treesitter.language.inspect()*
    Inspects the provided language.

    Inspecting provides some useful information on the language like node
    names, ...

    Parameters: ~
      • {lang}  (`string`) Language

    Return: ~
        (`table`)

register({lang}, {filetype})              *vim.treesitter.language.register()*
    Register a parser named {lang} to be used for {filetype}(s).

    Note: this adds or overrides the mapping for {filetype}, any existing
    mappings from other filetypes to {lang} will be preserved.

    Parameters: ~
      • {lang}      (`string`) Name of parser
      • {filetype}  (`string|string[]`) Filetype(s) to associate with lang


==============================================================================
Lua module: vim.treesitter.query                        *lua-treesitter-query*

                                        *vim.treesitter.query.add_directive()*
add_directive({name}, {handler}, {opts})
    Adds a new directive to be used in queries

    Handlers can set match level data by setting directly on the metadata
    object `metadata.key = value`. Additionally, handlers can set node level
    data by using the capture id on the metadata table
    `metadata[capture_id].key = value`

    Parameters: ~
      • {name}     (`string`) Name of the directive, without leading #
      • {handler}  (`fun(match: table<integer,TSNode[]>, pattern: integer, source: integer|string, predicate: any[], metadata: table)`)
                   • match: A table mapping capture IDs to a list of captured
                     nodes
                   • pattern: the index of the matching pattern in the query
                     file
                   • predicate: list of strings containing the full directive
                     being called, e.g. `(node (#set! conceal "-"))` would get
                     the predicate `{ "#set!", "conceal", "-" }`
      • {opts}     (`table`) A table with the following fields:
                   • {force}? (`boolean`) Override an existing predicate of
                     the same name
                   • {all}? (`boolean`) Use the correct implementation of the
                     match table where capture IDs map to a list of nodes
                     instead of a single node. Defaults to false (for backward
                     compatibility). This option will eventually become the
                     default and removed.

                                        *vim.treesitter.query.add_predicate()*
add_predicate({name}, {handler}, {opts})
    Adds a new predicate to be used in queries

    Parameters: ~
      • {name}     (`string`) Name of the predicate, without leading #
      • {handler}  (`fun(match: table<integer,TSNode[]>, pattern: integer, source: integer|string, predicate: any[], metadata: table)`)
                   • see |vim.treesitter.query.add_directive()| for argument
                     meanings
      • {opts}     (`table`) A table with the following fields:
                   • {force}? (`boolean`) Override an existing predicate of
                     the same name
                   • {all}? (`boolean`) Use the correct implementation of the
                     match table where capture IDs map to a list of nodes
                     instead of a single node. Defaults to false (for backward
                     compatibility). This option will eventually become the
                     default and removed.

edit({lang})                                     *vim.treesitter.query.edit()*
    Opens a live editor to query the buffer you started from.

    Can also be shown with *:EditQuery*.

    If you move the cursor to a capture name ("@foo"), text matching the
    capture is highlighted in the source buffer. The query editor is a scratch
    buffer, use `:write` to save it. You can find example queries at
    `$VIMRUNTIME/queries/`.

    Parameters: ~
      • {lang}  (`string?`) language to open the query editor for. If omitted,
                inferred from the current buffer's filetype.

get({lang}, {query_name})                         *vim.treesitter.query.get()*
    Returns the runtime query {query_name} for {lang}.

    Parameters: ~
      • {lang}        (`string`) Language to use for the query
      • {query_name}  (`string`) Name of the query (e.g. "highlights")

    Return: ~
        (`vim.treesitter.Query?`) Parsed query. `nil` if no query files are
        found.

                                            *vim.treesitter.query.get_files()*
get_files({lang}, {query_name}, {is_included})
    Gets the list of files used to make up a query

    Parameters: ~
      • {lang}         (`string`) Language to get query for
      • {query_name}   (`string`) Name of the query to load (e.g.,
                       "highlights")
      • {is_included}  (`boolean?`) Internal parameter, most of the time left
                       as `nil`

    Return: ~
        (`string[]`) query_files List of files to load for given query and
        language

lint({buf}, {opts})                              *vim.treesitter.query.lint()*
    Lint treesitter queries using installed parser, or clear lint errors.

    Use |treesitter-parsers| in runtimepath to check the query file in {buf}
    for errors:
    • verify that used nodes are valid identifiers in the grammar.
    • verify that predicates and directives are valid.
    • verify that top-level s-expressions are valid.

    The found diagnostics are reported using |diagnostic-api|. By default, the
    parser used for verification is determined by the containing folder of the
    query file, e.g., if the path ends in `/lua/highlights.scm`, the parser
    for the `lua` language will be used.

    Parameters: ~
      • {buf}   (`integer`) Buffer handle
      • {opts}  (`table?`) Optional keyword arguments:
                • {langs}? (`string|string[]`) Language(s) to use for checking
                  the query. If multiple languages are specified, queries are
                  validated for all of them
                • {clear} (`boolean`) Just clear current lint errors

list_directives()                     *vim.treesitter.query.list_directives()*
    Lists the currently available directives to use in queries.

    Return: ~
        (`string[]`) Supported directives.

list_predicates()                     *vim.treesitter.query.list_predicates()*
    Lists the currently available predicates to use in queries.

    Return: ~
        (`string[]`) Supported predicates.

omnifunc({findstart}, {base})                *vim.treesitter.query.omnifunc()*
    Omnifunc for completing node names and predicates in treesitter queries.

    Use via >lua
        vim.bo.omnifunc = 'v:lua.vim.treesitter.query.omnifunc'
<

    Parameters: ~
      • {findstart}  (`0|1`)
      • {base}       (`string`)

parse({lang}, {query})                          *vim.treesitter.query.parse()*
    Parse {query} as a string. (If the query is in a file, the caller should
    read the contents into a string before calling).

    Returns a `Query` (see |lua-treesitter-query|) object which can be used to
    search nodes in the syntax tree for the patterns defined in {query} using
    the `iter_captures` and `iter_matches` methods.

    Exposes `info` and `captures` with additional context about {query}.
    • `captures` contains the list of unique capture names defined in {query}.
    • `info.captures` also points to `captures`.
    • `info.patterns` contains information about predicates.

    Parameters: ~
      • {lang}   (`string`) Language to use for the query
      • {query}  (`string`) Query in s-expr syntax

    Return: ~
        (`vim.treesitter.Query`) Parsed query

    See also: ~
      • |vim.treesitter.query.get()|

                                                       *Query:iter_captures()*
Query:iter_captures({node}, {source}, {start}, {stop})
    Iterate over all captures from all matches inside {node}

    {source} is needed if the query contains predicates; then the caller must
    ensure to use a freshly parsed tree consistent with the current text of
    the buffer (if relevant). {start} and {stop} can be used to limit matches
    inside a row range (this is typically used with root node as the {node},
    i.e., to get syntax highlight matches in the current viewport). When
    omitted, the {start} and {stop} row values are used from the given node.

    The iterator returns four values: a numeric id identifying the capture,
    the captured node, metadata from any directives processing the match, and
    the match itself. The following example shows how to get captures by name: >lua
        for id, node, metadata, match in query:iter_captures(tree:root(), bufnr, first, last) do
          local name = query.captures[id] -- name of the capture in the query
          -- typically useful info about the node:
          local type = node:type() -- type of the captured node
          local row1, col1, row2, col2 = node:range() -- range of the capture
          -- ... use the info here ...
        end
<

    Note: ~
      • Captures are only returned if the query pattern of a specific capture
        contained predicates.

    Parameters: ~
      • {node}    (`TSNode`) under which the search will occur
      • {source}  (`integer|string`) Source buffer or string to extract text
                  from
      • {start}   (`integer?`) Starting line for the search. Defaults to
                  `node:start()`.
      • {stop}    (`integer?`) Stopping line for the search (end-exclusive).
                  Defaults to `node:end_()`.

    Return: ~
        (`fun(end_line: integer?): integer, TSNode, vim.treesitter.query.TSMetadata, TSQueryMatch`)
        capture id, capture node, metadata, match

                                                        *Query:iter_matches()*
Query:iter_matches({node}, {source}, {start}, {stop}, {opts})
    Iterates the matches of self on a given range.

    Iterate over all matches within a {node}. The arguments are the same as
    for |Query:iter_captures()| but the iterated values are different: an
    (1-based) index of the pattern in the query, a table mapping capture
    indices to a list of nodes, and metadata from any directives processing
    the match.

    WARNING: Set `all=true` to ensure all matching nodes in a match are
    returned, otherwise only the last node in a match is returned, breaking
    captures involving quantifiers such as `(comment)+ @comment`. The default
    option `all=false` is only provided for backward compatibility and will be
    removed after Nvim 0.10.

    Example: >lua
        for pattern, match, metadata in cquery:iter_matches(tree:root(), bufnr, 0, -1, { all = true }) do
          for id, nodes in pairs(match) do
            local name = query.captures[id]
            for _, node in ipairs(nodes) do
              -- `node` was captured by the `name` capture in the match

              local node_data = metadata[id] -- Node level metadata
              ... use the info here ...
            end
          end
        end
<

    Parameters: ~
      • {node}    (`TSNode`) under which the search will occur
      • {source}  (`integer|string`) Source buffer or string to search
      • {start}   (`integer?`) Starting line for the search. Defaults to
                  `node:start()`.
      • {stop}    (`integer?`) Stopping line for the search (end-exclusive).
                  Defaults to `node:end_()`.
      • {opts}    (`table?`) Optional keyword arguments:
                  • max_start_depth (integer) if non-zero, sets the maximum
                    start depth for each match. This is used to prevent
                    traversing too deep into a tree.
                  • match_limit (integer) Set the maximum number of
                    in-progress matches (Default: 256).
                  • all (boolean) When set, the returned match table maps
                    capture IDs to a list of nodes. Older versions of
                    iter_matches incorrectly mapped capture IDs to a single
                    node, which is incorrect behavior. This option will
                    eventually become the default and removed.

    Return: ~
        (`fun(): integer, table<integer, TSNode[]>, table`) pattern id, match,
        metadata

set({lang}, {query_name}, {text})                 *vim.treesitter.query.set()*
    Sets the runtime query named {query_name} for {lang}

    This allows users to override any runtime files and/or configuration set
    by plugins.

    Parameters: ~
      • {lang}        (`string`) Language to use for the query
      • {query_name}  (`string`) Name of the query (e.g., "highlights")
      • {text}        (`string`) Query text (unparsed).


==============================================================================
Lua module: vim.treesitter.languagetree          *lua-treesitter-languagetree*

A *LanguageTree* contains a tree of parsers: the root treesitter parser for
{lang} and any "injected" language parsers, which themselves may inject other
languages, recursively. For example a Lua buffer containing some Vimscript
commands needs multiple parsers to fully understand its contents.

To create a LanguageTree (parser object) for a given buffer and language, use: >lua
    local parser = vim.treesitter.get_parser(bufnr, lang)
<

(where `bufnr=0` means current buffer). `lang` defaults to 'filetype'. Note:
currently the parser is retained for the lifetime of a buffer but this may
change; a plugin should keep a reference to the parser object if it wants
incremental updates.

Whenever you need to access the current syntax tree, parse the buffer: >lua
    local tree = parser:parse({ start_row, end_row })
<

This returns a table of immutable |treesitter-tree| objects representing the
current state of the buffer. When the plugin wants to access the state after a
(possible) edit it must call `parse()` again. If the buffer wasn't edited, the
same tree will be returned again without extra work. If the buffer was parsed
before, incremental parsing will be done of the changed parts.

Note: To use the parser directly inside a |nvim_buf_attach()| Lua callback,
you must call |vim.treesitter.get_parser()| before you register your callback.
But preferably parsing shouldn't be done directly in the change callback
anyway as they will be very frequent. Rather a plugin that does any kind of
analysis on a tree should use a timer to throttle too frequent updates.


LanguageTree:children()                              *LanguageTree:children()*
    Returns a map of language to child tree.

LanguageTree:contains({range})                       *LanguageTree:contains()*
    Determines whether {range} is contained in the |LanguageTree|.

    Parameters: ~
      • {range}  (`Range4`) `{ start_line, start_col, end_line, end_col }`

    Return: ~
        (`boolean`)

LanguageTree:destroy()                                *LanguageTree:destroy()*
    Destroys this |LanguageTree| and all its children.

    Any cleanup logic should be performed here.

    Note: This DOES NOT remove this tree from a parent. Instead,
    `remove_child` must be called on the parent to remove it.

LanguageTree:for_each_tree({fn})                *LanguageTree:for_each_tree()*
    Invokes the callback for each |LanguageTree| recursively.

    Note: This includes the invoking tree's child trees as well.

    Parameters: ~
      • {fn}  (`fun(tree: TSTree, ltree: vim.treesitter.LanguageTree)`)

LanguageTree:included_regions()              *LanguageTree:included_regions()*
    Gets the set of included regions managed by this LanguageTree. This can be
    different from the regions set by injection query, because a partial
    |LanguageTree:parse()| drops the regions outside the requested range.

    Return: ~
        (`table<integer, Range6[]>`)

LanguageTree:invalidate({reload})                  *LanguageTree:invalidate()*
    Invalidates this parser and its children.

    Should only be called when the tracked state of the LanguageTree is not
    valid against the parse tree in treesitter. Doesn't clear filesystem
    cache. Called often, so needs to be fast.

    Parameters: ~
      • {reload}  (`boolean?`)

LanguageTree:is_valid({exclude_children})            *LanguageTree:is_valid()*
    Returns whether this LanguageTree is valid, i.e., |LanguageTree:trees()|
    reflects the latest state of the source. If invalid, user should call
    |LanguageTree:parse()|.

    Parameters: ~
      • {exclude_children}  (`boolean?`) whether to ignore the validity of
                            children (default `false`)

    Return: ~
        (`boolean`)

LanguageTree:lang()                                      *LanguageTree:lang()*
    Gets the language of this tree node.

                                           *LanguageTree:language_for_range()*
LanguageTree:language_for_range({range})
    Gets the appropriate language that contains {range}.

    Parameters: ~
      • {range}  (`Range4`) `{ start_line, start_col, end_line, end_col }`

    Return: ~
        (`vim.treesitter.LanguageTree`) tree Managing {range}

                                         *LanguageTree:named_node_for_range()*
LanguageTree:named_node_for_range({range}, {opts})
    Gets the smallest named node that contains {range}.

    Parameters: ~
      • {range}  (`Range4`) `{ start_line, start_col, end_line, end_col }`
      • {opts}   (`table?`) A table with the following fields:
                 • {ignore_injections}? (`boolean`, default: `true`) Ignore
                   injected languages

    Return: ~
        (`TSNode?`)

LanguageTree:parse({range})                             *LanguageTree:parse()*
    Recursively parse all regions in the language tree using
    |treesitter-parsers| for the corresponding languages and run injection
    queries on the parsed trees to determine whether child trees should be
    created and parsed.

    Any region with empty range (`{}`, typically only the root tree) is always
    parsed; otherwise (typically injections) only if it intersects {range} (or
    if {range} is `true`).

    Parameters: ~
      • {range}  (`boolean|Range?`) Parse this range in the parser's source.
                 Set to `true` to run a complete parse of the source (Note:
                 Can be slow!) Set to `false|nil` to only parse regions with
                 empty ranges (typically only the root tree without
                 injections).

    Return: ~
        (`table<integer, TSTree>`)

                                                 *LanguageTree:register_cbs()*
LanguageTree:register_cbs({cbs}, {recursive})
    Registers callbacks for the |LanguageTree|.

    Parameters: ~
      • {cbs}        (`table<TSCallbackNameOn,function>`) An
                     |nvim_buf_attach()|-like table argument with the
                     following handlers:
                     • `on_bytes` : see |nvim_buf_attach()|, but this will be
                       called after the parsers callback.
                     • `on_changedtree` : a callback that will be called every
                       time the tree has syntactical changes. It will be
                       passed two arguments: a table of the ranges (as node
                       ranges) that changed and the changed tree.
                     • `on_child_added` : emitted when a child is added to the
                       tree.
                     • `on_child_removed` : emitted when a child is removed
                       from the tree.
                     • `on_detach` : emitted when the buffer is detached, see
                       |nvim_buf_detach_event|. Takes one argument, the number
                       of the buffer.
      • {recursive}  (`boolean?`) Apply callbacks recursively for all
                     children. Any new children will also inherit the
                     callbacks.

LanguageTree:source()                                  *LanguageTree:source()*
    Returns the source content of the language tree (bufnr or string).

                                               *LanguageTree:tree_for_range()*
LanguageTree:tree_for_range({range}, {opts})
    Gets the tree that contains {range}.

    Parameters: ~
      • {range}  (`Range4`) `{ start_line, start_col, end_line, end_col }`
      • {opts}   (`table?`) A table with the following fields:
                 • {ignore_injections}? (`boolean`, default: `true`) Ignore
                   injected languages

    Return: ~
        (`TSTree?`)

LanguageTree:trees()                                    *LanguageTree:trees()*
    Returns all trees of the regions parsed by this parser. Does not include
    child languages. The result is list-like if
    • this LanguageTree is the root, in which case the result is empty or a
      singleton list; or
    • the root LanguageTree is fully parsed.

    Return: ~
        (`table<integer, TSTree>`)


 vim:tw=78:ts=8:sw=4:sts=4:et:ft=help:norl: