diff options
Diffstat (limited to 'runtime/doc/treesitter.txt')
| -rw-r--r-- | runtime/doc/treesitter.txt | 74 |
1 files changed, 19 insertions, 55 deletions
diff --git a/runtime/doc/treesitter.txt b/runtime/doc/treesitter.txt index 070659ce3d..9f17b9fb54 100644 --- a/runtime/doc/treesitter.txt +++ b/runtime/doc/treesitter.txt @@ -947,7 +947,7 @@ parse({lang}, {query}) *vim.treesitter.query.parse()* Query Parsed query *Query:iter_captures()* -Query:iter_captures({self}, {node}, {source}, {start}, {stop}) +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 @@ -976,14 +976,13 @@ Query:iter_captures({self}, {node}, {source}, {start}, {stop}) from • {start} (integer) Starting line for the search • {stop} (integer) Stopping line for the search (end-exclusive) - • {self} Return: ~ (fun(): integer, TSNode, TSMetadata): capture id, capture node, metadata *Query:iter_matches()* -Query:iter_matches({self}, {node}, {source}, {start}, {stop}, {opts}) +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 @@ -1015,7 +1014,6 @@ Query:iter_matches({self}, {node}, {source}, {start}, {stop}, {opts}) start depth for each match. This is used to prevent traversing too deep into a tree. Requires treesitter >= 0.20.9. - • {self} Return: ~ (fun(): integer, table<integer,TSNode>, table): pattern id, match, @@ -1036,12 +1034,9 @@ set({lang}, {query_name}, {text}) *vim.treesitter.query.set()* ============================================================================== Lua module: vim.treesitter.highlighter *lua-treesitter-highlighter* -TSHighlighter:destroy({self}) *TSHighlighter:destroy()* +TSHighlighter:destroy() *TSHighlighter:destroy()* Removes all internal references to the highlighter - Parameters: ~ - • {self} - ============================================================================== Lua module: vim.treesitter.languagetree *lua-treesitter-languagetree* @@ -1084,97 +1079,78 @@ 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({self}) *LanguageTree:children()* +LanguageTree:children() *LanguageTree:children()* Returns a map of language to child tree. - Parameters: ~ - • {self} - -LanguageTree:contains({self}, {range}) *LanguageTree:contains()* +LanguageTree:contains({range}) *LanguageTree:contains()* Determines whether {range} is contained in the |LanguageTree|. Parameters: ~ • {range} (table) `{ start_line, start_col, end_line, end_col }` - • {self} Return: ~ (boolean) -LanguageTree:destroy({self}) *LanguageTree:destroy()* +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. - Parameters: ~ - • {self} - *LanguageTree:for_each_child()* -LanguageTree:for_each_child({self}, {fn}, {include_self}) +LanguageTree:for_each_child({fn}, {include_self}) Invokes the callback for each |LanguageTree| and its children recursively Parameters: ~ • {fn} fun(tree: LanguageTree, lang: string) • {include_self} (boolean|nil) Whether to include the invoking tree in the results - • {self} -LanguageTree:for_each_tree({self}, {fn}) *LanguageTree:for_each_tree()* +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: LanguageTree) - • {self} -LanguageTree:included_regions({self}) *LanguageTree:included_regions()* +LanguageTree:included_regions() *LanguageTree:included_regions()* Gets the set of included regions - Parameters: ~ - • {self} - Return: ~ integer[][] -LanguageTree:invalidate({self}, {reload}) *LanguageTree:invalidate()* +LanguageTree:invalidate({reload}) *LanguageTree:invalidate()* Invalidates this parser and all its children Parameters: ~ • {reload} (boolean|nil) - • {self} - *LanguageTree:is_valid()* -LanguageTree:is_valid({self}, {exclude_children}) +LanguageTree:is_valid({exclude_children}) *LanguageTree:is_valid()* Determines whether this tree is valid. If the tree is invalid, call `parse()` . This will return the updated tree. Parameters: ~ • {exclude_children} (boolean|nil) - • {self} Return: ~ (boolean) -LanguageTree:lang({self}) *LanguageTree:lang()* +LanguageTree:lang() *LanguageTree:lang()* Gets the language of this tree node. - Parameters: ~ - • {self} - *LanguageTree:language_for_range()* -LanguageTree:language_for_range({self}, {range}) +LanguageTree:language_for_range({range}) Gets the appropriate language that contains {range}. Parameters: ~ • {range} (table) `{ start_line, start_col, end_line, end_col }` - • {self} Return: ~ |LanguageTree| Managing {range} *LanguageTree:named_node_for_range()* -LanguageTree:named_node_for_range({self}, {range}, {opts}) +LanguageTree:named_node_for_range({range}, {opts}) Gets the smallest named node that contains {range}. Parameters: ~ @@ -1182,24 +1158,20 @@ LanguageTree:named_node_for_range({self}, {range}, {opts}) • {opts} (table|nil) Optional keyword arguments: • ignore_injections boolean Ignore injected languages (default true) - • {self} Return: ~ |TSNode| | nil Found node -LanguageTree:parse({self}) *LanguageTree:parse()* +LanguageTree:parse() *LanguageTree:parse()* Parses all defined regions using a treesitter parser for the language this tree represents. This will run the injection query for this language to determine if any child languages should be created. - Parameters: ~ - • {self} - Return: ~ TSTree[] *LanguageTree:register_cbs()* -LanguageTree:register_cbs({self}, {cbs}, {recursive}) +LanguageTree:register_cbs({cbs}, {recursive}) Registers callbacks for the |LanguageTree|. Parameters: ~ @@ -1219,16 +1191,12 @@ LanguageTree:register_cbs({self}, {cbs}, {recursive}) number of the buffer. • {recursive?} boolean Apply callbacks recursively for all children. Any new children will also inherit the callbacks. - • {self} -LanguageTree:source({self}) *LanguageTree:source()* +LanguageTree:source() *LanguageTree:source()* Returns the source content of the language tree (bufnr or string). - Parameters: ~ - • {self} - *LanguageTree:tree_for_range()* -LanguageTree:tree_for_range({self}, {range}, {opts}) +LanguageTree:tree_for_range({range}, {opts}) Gets the tree that contains {range}. Parameters: ~ @@ -1236,16 +1204,12 @@ LanguageTree:tree_for_range({self}, {range}, {opts}) • {opts} (table|nil) Optional keyword arguments: • ignore_injections boolean Ignore injected languages (default true) - • {self} Return: ~ TSTree|nil -LanguageTree:trees({self}) *LanguageTree:trees()* +LanguageTree:trees() *LanguageTree:trees()* Returns all trees this language tree contains. Does not include child languages. - Parameters: ~ - • {self} - vim:tw=78:ts=8:sw=4:sts=4:et:ft=help:norl: |