Treesitter

Nvim 的 :help 页面,生成源代码 使用 tree-sitter-vimdoc 解析器。


Treesitter 集成
Nvim 集成了 tree-sitter 库,用于对缓冲区进行增量解析:https://tree-sitter.github.io/tree-sitter/
警告: Treesitter 支持仍处于实验阶段,可能会频繁更改。本文档也可能无法完全反映最新更改。

解析器文件 treesitter-parsers

解析器是 treesitter 的核心。它们是 treesitter 将在 parser 运行时目录中搜索的库。
Nvim 包含以下解析器
C
Lua
Markdown
Vimscript
Vimdoc
Treesitter 查询文件 ft-query-plugin
您可以手动安装更多解析器,或者使用像 https://github.com/nvim-treesitter/nvim-treesitter 这样的插件。
解析器在任何 'runtimepath' 目录中按 parser/{lang}.* 搜索。如果找到多个相同语言的解析器,则使用第一个解析器。(注意:这通常意味着优先级“用户配置 > 插件 > 捆绑”。)
从其文件路径加载解析器
vim.treesitter.language.add('python', { path = "/path/to/python.so" })
如果文件系统区分大小写,则解析器名称假定为小写。
要将某些 文件类型 与 treesitter 语言(解析器名称)关联,请使用 vim.treesitter.language.register()。例如,要将 xml treesitter 解析器用于文件类型为 svgxslt 的缓冲区,请使用
vim.treesitter.language.register('xml', { 'svg', 'xslt' })
如果 Nvim 使用 ENABLE_WASMTIME 构建,则也可以加载 wasm 解析器
vim.treesitter.language.add('python', { path = "/path/to/python.wasm" })

TREESITTER 查询 treesitter-query

Treesitter 查询是一种提取关于已解析 TSTree 信息的方法,例如,用于突出显示。简而言之,一个 query 包含一个或多个模式。一个 pattern 在语法树中的节点类型上定义。一个 match 对应于与模式匹配的语法树的特定元素。模式可以选择性地定义捕获和谓词。一个 capture 允许您将名称与模式中的特定节点关联。一个 predicate 为匹配添加任意元数据和条件数据。
查询使用一种类似 Lisp 的语言编写,该语言在 https://tree-sitter.github.io/tree-sitter/using-parsers#query-syntax 中有说明。注意:该页面中列出的谓词与 Nvim 支持的谓词不同。有关 Nvim 支持的谓词的完整列表,请参阅 treesitter-predicates
Nvim 在 runtimepath 下的 queries 目录中以 *.scm 文件形式查找查询,每个文件包含特定语言和目的的查询,例如,queries/lua/highlights.scm 用于突出显示 Lua 文件。默认情况下,使用 runtimepath 上的第一个查询(这通常意味着用户配置优先于插件,插件优先于 Nvim 捆绑的查询)。如果查询应该扩展其他查询而不是替换它们,请使用 treesitter-query-modeline-extends
有关从 Lua 使用 treesitter 查询的可用方法列表,请参阅 lua-treesitter-query

TREESITTER 查询谓词 treesitter-predicates

谓词是特殊的方案节点,它们被计算以有条件地捕获节点。例如,eq? 谓词可以按以下方式使用
((identifier) @variable.builtin
  (#eq? @variable.builtin "self"))
仅匹配与文本 "self" 相对应的标识符。例如,此类查询可用于以不同的方式突出显示内置函数或变量。
以下谓词是内置的
eq? treesitter-predicate-eq?
将字符串与与节点对应的文本匹配
((identifier) @variable.builtin (#eq? @variable.builtin "self"))
((node1) @left (node2) @right (#eq? @left @right))
any-eq? treesitter-predicate-any-eq?
类似于 eq?,但对于量化模式,仅需一个捕获的节点匹配即可。
match? treesitter-predicate-match?
vim-match? treesitter-predicate-vim-match?
regexp 与与节点对应的文本匹配
((identifier) @constant (#match? @constant "^[A-Z_]+$"))
注意:^$ 锚点将匹配节点文本的开头和结尾。
any-match? treesitter-predicate-any-match?
any-vim-match? treesitter-predicate-any-vim-match?
类似于 match?,但对于量化模式,仅需一个捕获的节点匹配即可。
lua-match? treesitter-predicate-lua-match?
lua-patterns 与与节点对应的文本匹配,类似于 match?
any-lua-match? treesitter-predicate-any-lua-match?
类似于 lua-match?,但对于量化模式,仅需一个捕获的节点匹配即可。
contains? treesitter-predicate-contains?
将字符串与与节点对应的文本的一部分匹配
((identifier) @foo (#contains? @foo "foo"))
((identifier) @foo-bar (#contains? @foo-bar "foo" "bar"))
any-contains? treesitter-predicate-any-contains?
类似于 contains?,但对于量化模式,仅需一个捕获的节点匹配即可。
any-of? treesitter-predicate-any-of?
将给定字符串中的任何一个与与节点对应的文本匹配
((identifier) @foo (#any-of? @foo "foo" "bar"))
这是检查节点是否匹配多个关键字的推荐方法,因为它对此进行了优化。
has-ancestor? treesitter-predicate-has-ancestor?
将给定节点类型中的任何一个与节点的所有祖先匹配
((identifier) @variable.builtin
  (#any-of? @variable.builtin "begin" "end")
  (#has-ancestor? @variable.builtin range_expression))
has-parent? treesitter-predicate-has-parent?
将给定节点类型中的任何一个与节点的直接祖先匹配
(((field_expression
     (field_identifier) @method)) @_parent
 (#has-parent? @_parent template_method function_declarator))
lua-treesitter-not-predicate
每个谓词都有一个以 not- 为前缀的谓词,它只是谓词的否定。
lua-treesitter-all-predicate
lua-treesitter-any-predicate
查询可以使用量词捕获多个节点。当捕获包含多个节点时,谓词仅在捕获包含的所有节点都与谓词匹配时才匹配。某些谓词(eq?match?lua-match?contains?)接受 any- 前缀,以在捕获包含的任何节点与谓词匹配时匹配。
例如,考虑以下 Lua 代码
-- TODO: This is a
-- very long
-- comment (just imagine it)
使用以下谓词查询
(((comment)+ @comment)
 (#match? @comment "TODO"))
此查询将不匹配,因为 @comment 捕获的节点并非全部与谓词匹配。相反,请使用
(((comment)+ @comment)
 (#any-match? @comment "TODO"))
可以通过 vim.treesitter.query.add_predicate() 添加更多谓词。使用 vim.treesitter.query.list_predicates() 列出所有可用的谓词。

TREESITTER 查询指令 treesitter-directives

Treesitter 指令存储节点或匹配的元数据并执行副作用。例如,set! 指令为匹配或节点设置元数据
((identifier) @foo (#set! type "parameter"))
以下指令是内置的
set! treesitter-directive-set!
为特定匹配或捕获设置键/值元数据。值可作为 metadata[key](匹配特定)或 metadata[capture_id][key](捕获特定)访问。
参数
{capture_id}(可选){key} {value}
示例
((identifier) @foo (#set! @foo kind "parameter"))
((node1) @left (node2) @right (#set! type "pair"))
((codeblock) @markup.raw.block (#set! priority 90))
offset! treesitter-directive-offset!
获取捕获节点的范围并应用偏移量。这将以列表的形式为捕获节点设置一个新的范围,如 { {start_row}, {start_col}, {end_row}, {end_col} },其中 capture_id 作为 metadata[capture_id].range。对 treesitter-language-injections 有用。
参数
{capture_id} {start_row} {start_col} {end_row} {end_col}
示例
((identifier) @constant (#offset! @constant 0 1 0 -1))
gsub! treesitter-directive-gsub!
使用 lua-pattern 转换节点的内容。这将设置一个新的 metadata[capture_id].text
参数
{capture_id} {pattern} {replacement}
示例
(#gsub! @_node ".*%.(.*)" "%1")
trim! treesitter-directive-trim!
从节点末尾修剪空白行。这将设置一个新的 metadata[capture_id].range
参数
{capture_id}
示例
(#trim! @fold)
可以通过 vim.treesitter.query.add_directive() 添加更多指令。使用 vim.treesitter.query.list_directives() 列出所有可用的指令。

TREESITTER 查询模式行 treesitter-query-modeline

Nvim 支持使用一组“模式行”来自定义查询的行为,即查询中以 ; 开头的注释。以下是当前支持的模式行替代方案
inherits: {lang}... treesitter-query-modeline-inherits
指定此查询应继承 {lang} 的查询。这将递归地向下遍历 {lang} 的查询,除非它们包含在括号中:({lang}) 注意:这是为了包含来自另一种语言的查询。如果您希望查询扩展同一语言的查询,请使用 extends
extends treesitter-query-modeline-extends
指定此查询应作为查询的扩展使用,即它应与其他查询合并。 注意:扩展的顺序以及将用作基础的查询取决于您的 'runtimepath' 值。
注意:这些模式行注释必须位于查询的顶部,但可以重复,例如,以下两个模式行块都是有效的
;; inherits: typescript,jsx
;; extends
;; extends
;;
;; inherits: css

TREESITTER 语法高亮 treesitter-highlight

语法高亮通过名为 highlights.scm 的查询指定,该查询将已解析 TSTree 中的 TSNode 匹配到 capture,该 capture 可以分配高亮组。例如,查询
(parameters (identifier) @variable.parameter)
匹配函数 `parameters` 节点内的任何 identifier 节点,与名为 @variable.parameter 的捕获内容匹配。例如,对于 Lua 代码
function f(foo, bar) end
它将被解析为(参见 :InspectTree
(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]
上面的查询将突出显示 foobar 作为 @variable.parameter
还可以匹配字面量表达式(前提是解析器返回它们)
[
  "if"
  "else"
] @keyword.conditional
假设在运行时路径中找到合适的解析器和 highlights.scm 查询,则可以通过 vim.treesitter.start() 简单地为当前缓冲区启用 treesitter 突出显示。
treesitter-highlight-groups
@ 为前缀的捕获名称可以直接用作突出显示组。对于许多常用的捕获,相应的突出显示组默认情况下会链接到 Nvim 的标准 highlight-groups(例如,@comment 链接到 Comment),但可以在颜色方案中覆盖。
实现了一个回退系统,使更具体的组回退到更通用的组。例如,在具有单独的文档注释的语言(例如,c、java 等)中,可以使用 @comment.documentation。如果未定义此组,则使用普通 @comment 的突出显示。这样,现有的颜色方案就可以开箱即用,但可以为使它们可用的查询添加更具体的变体。
作为一项附加规则,捕获突出显示始终可以通过语言进行专门化,方法是在附加点后附加语言名称。例如,要根据语言不同地突出显示注释
hi @comment.c guifg=Blue
hi @comment.lua guifg=DarkBlue
hi link @comment.documentation.java String
以下是 Nvim 查询中使用的标准捕获列表,根据当前颜色方案突出显示(使用 :Inspect 查看其中一个的精确定义)
@variable 各种变量名称 @variable.builtin 内置变量名称(例如 thisself) @variable.parameter 函数参数 @variable.parameter.builtin 特殊参数(例如 _it) @variable.member 对象和结构体字段
@constant 常量标识符 @constant.builtin 内置常量值 @constant.macro 预处理器定义的常量
@module 模块或命名空间 @module.builtin 内置模块或命名空间 @label GOTO 和其他标签(例如,C 中的 label:),包括 heredoc 标签
@string 字符串字面量 @string.documentation 文档化代码的字符串(例如,Python 文档字符串) @string.regexp 正则表达式 @string.escape 转义序列 @string.special 其他特殊字符串(例如,日期) @string.special.symbol 符号或原子 @string.special.path 文件名 @string.special.url URI(例如,超链接)
@character 字符字面量 @character.special 特殊字符(例如,通配符)
@boolean 布尔字面量 @number 数字字面量 @number.float 浮点数字面量
@type 类型或类定义和注释 @type.builtin 内置类型 @type.definition 类型定义中的标识符(例如,C 中的 typedef <type> <identifier>
@attribute 属性注释(例如,Python 装饰器、Rust 生存期) @attribute.builtin 内置注释(例如,Python 中的 @property) @property 键值对中的键
@function 函数定义 @function.builtin 内置函数 @function.call 函数调用 @function.macro 预处理器宏
@function.method 方法定义 @function.method.call 方法调用
@constructor 构造函数调用和定义 @operator 符号运算符(例如 +*
@keyword 不属于特定类别的关键字 @keyword.coroutine 与协程相关的关键字(例如,Go 中的 go、Python 中的 async/await) @keyword.function 定义函数的关键字(例如,Go 中的 func、Python 中的 def) @keyword.operator 作为英文单词的运算符(例如,andor) @keyword.import 用于包含或导出模块的关键字(例如,Python 中的 importfrom) @keyword.type 描述命名空间和复合类型的关键字(例如,structenum) @keyword.modifier 修改其他结构的关键字(例如,conststaticpublic) @keyword.repeat 与循环相关的关键字(例如,forwhile) @keyword.return 像 returnyield 这样的关键字 @keyword.debug 与调试相关的关键字 @keyword.exception 与异常相关的关键字(例如,throwcatch
@keyword.conditional 与条件相关的关键字(例如,ifelse) @keyword.conditional.ternary 三元运算符(例如,?:
@keyword.directive 各种预处理器指令和 Shebang @keyword.directive.define 预处理器定义指令
@punctuation.delimiter 分隔符(例如,;.,) @punctuation.bracket 括号(例如,(){}[]) @punctuation.special 特殊符号(例如,字符串插值中的 {}
@comment 行注释和块注释 @comment.documentation 文档化代码的注释
@comment.error 错误类型注释(例如,ERRORFIXMEDEPRECATED) @comment.warning 警告类型注释(例如,WARNINGFIXHACK) @comment.todo 待办事项类型注释(例如,TODOWIP) @comment.note 注释类型注释(例如,NOTEINFOXXX
@markup.strong 粗体文本 @markup.italic 斜体文本 @markup.strikethrough 删除线文本 @markup.underline 下划线文本(仅用于字面量下划线标记!)
@markup.heading 标题、标题(包括标记) @markup.heading.1 顶级标题 @markup.heading.2 部分标题 @markup.heading.3 小节标题 @markup.heading.4 等等 @markup.heading.5 等等 @markup.heading.6 六级应该足够任何人了
@markup.quote 块引用 @markup.math 数学环境(例如,LaTeX 中的 $ ... $
@markup.link 文本引用、脚注、引文等 @markup.link.label 链接、引用描述 @markup.link.url URL 样式链接
@markup.raw 字面量或逐字文本(例如,内联代码) @markup.raw.block 字面量或逐字文本作为独立的块
@markup.list 列表标记 @markup.list.checked 已选中待办事项样式列表标记 @markup.list.unchecked 未选中待办事项样式列表标记
@diff.plus 添加的文本(用于 diff 文件) @diff.minus 删除的文本(用于 diff 文件) @diff.delta 更改的文本(用于 diff 文件)
@tag XML 样式标签名称(例如,在 XML、HTML 等中) @tag.builtin 内置标签名称(例如,HTML5 标签) @tag.attribute XML 样式标签属性 @tag.delimiter XML 样式标签分隔符
treesitter-highlight-spell
特殊的 @spell 捕获可以用来指示一个节点应该被 Nvim 的内置 spell 检查器进行拼写检查。例如,以下捕获将注释标记为要检查
(comment) @spell
还有 @nospell,它禁用对具有 @spell 的区域的拼写检查。
treesitter-highlight-conceal
Treesitter 突出显示支持使用 conceal 元数据进行 conceal。按照惯例,要隐藏的节点被捕获为 @conceal,但可以使用任何捕获。例如,以下查询可用于隐藏 Markdown 中的代码块分隔符
(fenced_code_block_delimiter @conceal (#set! conceal ""))
还可以用单个字符替换节点,该字符(与传统语法不同)可以被赋予自定义突出显示。例如,以下(不建议)查询将 != 运算符替换为 Unicode 字符,该字符仍然与其他运算符的突出显示方式相同
"!=" @operator (#set! conceal "≠")
以这种方式指定的隐藏符合 'conceallevel'
treesitter-highlight-priority
Treesitter 使用 nvim_buf_set_extmark() 设置具有默认优先级 100 的突出显示。这使得插件可以设置低于或高于 treesitter 的突出显示优先级。还可以通过设置查询模式的 "priority" 元数据属性来手动更改单个查询模式的优先级
((super_important_node) @superimportant (#set! priority 105))

TREESITTER 语言注入 treesitter-language-injections

一些源文件包含用多种不同语言编写的代码。例如
HTML 文件,可以在 <script> 标签内包含 JavaScript,在 <style> 标签内包含 CSS
ERB 文件,在 <% %> 标签内包含 Ruby,在这些标签之外包含 HTML
PHP 文件,可以在 <php 标签之间包含 HTML
JavaScript 文件,在正则表达式字面量中包含正则表达式语法
Ruby,可以在 heredoc 字面量内包含代码片段,其中 heredoc 分隔符通常指示语言
Lua,可以在 vim.cmd() 调用内包含 Vimscript 代码片段。
Vimscript,可以在 :lua-heredoc 块内包含 Lua 代码片段。
所有这些示例都可以用父语法树和一个或多个注入语法树来建模,这些树驻留在父树中的某些节点内。语言注入查询允许你使用以下捕获来指定这些“注入”
@injection.content - 指示捕获的节点应该使用另一种语言重新解析其内容。
@injection.language - 指示捕获的节点的文本可能包含应该用于重新解析 @injection.content 的语言名称。
@injection.filename - 指示捕获的节点的文本可能包含一个文件名;然后通过 vim.filetype.match() 查找相应的文件类型,并将其视为应该用于重新解析 @injection.content 的语言名称。
语言注入行为也可以通过与模式关联的一些属性进行配置
injection.language - 可用于硬编码特定语言的名称。
injection.combined - 指示树中所有匹配的节点都应该将其内容解析为一个嵌套的文档。
injection.include-children - 指示 @injection.content 节点的整个文本应该被重新解析,包括其子节点的文本。默认情况下,子节点的文本将从注入的文档中排除。
injection.self - 指示节点的文本应该使用与节点的 LanguageTree 相同的语言解析。
injection.parent - 指示捕获的节点的文本应该使用与节点的父 LanguageTree 相同的语言解析。

VIM.TREESITTER lua-treesitter

本文档的其余部分是 vim.treesitter Lua 模块的参考手册,它是 Nvim treesitter 集成的主要接口。以下内容中的大部分内容是从函数文档自动生成的。
vim.treesitter.language_version
捆绑的 treesitter 库支持的最新解析器 ABI 版本。
vim.treesitter.minimum_language_version
捆绑的 treesitter 库支持的最早解析器 ABI 版本。

TREESITTER 树 treesitter-tree TSTree

“treesitter 树”表示缓冲区的解析内容,可以用于执行进一步的分析。它是对 treesitter 库持有的对象的 userdata 引用。
treesitter 树的实例 TSTree 支持以下方法。
TSTree:copy() TSTree:copy()
返回 TSTree 的副本。
返回
(TSTree)
TSTree:root() TSTree:root()
返回此树的根节点。
返回
(TSNode)

TREESITTER 节点 treesitter-node TSNode

“treesitter 节点”表示缓冲区的解析内容中的一个特定元素,可以被 Query 捕获,例如,用于突出显示。它是对 treesitter 库持有的对象的 userdata 引用。
treesitter 节点的实例 TSNode 支持以下方法。
TSNode:byte_length() TSNode:byte_length()
返回此节点所跨越的字节数。
返回
(integer)
TSNode:child({index}) TSNode:child()
获取给定 {index} 处的节点的子节点,其中零表示第一个子节点。
参数
{index} (integer)
返回
(TSNode?)
TSNode:child_count() TSNode:child_count()
获取节点的子节点数量。
返回
(integer)
TSNode:child_with_descendant()
TSNode:child_with_descendant({descendant}) 获取包含 {descendant} 的节点的子节点(包括 {descendant})。
例如,使用以下节点层次结构
a -> b -> c
a:child_with_descendant(c) == b
a:child_with_descendant(b) == b
a:child_with_descendant(a) == nil
参数
{descendant} (TSNode)
返回
(TSNode?)
TSNode:descendant_for_range()
TSNode:descendant_for_range({start_row}, {start_col}, {end_row}, {end_col}) 获取此节点内跨越给定 (行,列) 位置范围的最小节点
参数
{start_row} (integer)
{start_col} (integer)
{end_row} (integer)
{end_col} (integer)
返回
(TSNode?)
TSNode:end_() TSNode:end_()
获取节点的结束位置。返回三个值:行、列和总字节数(均为从零开始)。
返回 (多个)
(integer) (integer) (integer)
TSNode:equal({node}) TSNode:equal()
检查 {node} 是否引用同一树中的同一节点。
参数
{node} (TSNode)
返回
(boolean)
TSNode:extra() TSNode:extra()
检查节点是否为额外节点。额外节点代表诸如注释之类的内容,这些内容不是语法所必需的,但可以在任何地方出现。
返回
(boolean)
TSNode:field({name}) TSNode:field()
返回对应于 {name} 字段的节点的表。
参数
{name} (string)
返回
(TSNode[])
TSNode:has_changes() TSNode:has_changes()
检查语法节点是否已被编辑。
返回
(boolean)
TSNode:has_error() TSNode:has_error()
检查节点是否为语法错误或包含任何语法错误。
返回
(boolean)
TSNode:id() TSNode:id()
获取节点在其自身树内的唯一标识符。
不保证此标识符的内部表示形式,除了是具有值相等性的基本 Lua 类型(因此不是表)之外。目前它是一个(不可打印的)字符串。
注意: id 不保证对来自不同树的节点是唯一的。
返回
(string)
TSNode:iter_children() TSNode:iter_children()
迭代 {TSNode} 的所有直接子节点,无论它们是否命名。返回子节点以及最终对应于此子节点的字段名称。
返回
(fun(): TSNode, string)
TSNode:missing() TSNode:missing()
检查节点是否丢失。丢失的节点由解析器插入,以便从某些类型的语法错误中恢复。
返回
(boolean)
TSNode:named() TSNode:named()
检查节点是否命名。命名节点对应于语法中的命名规则,而匿名节点对应于语法中的字符串文字。
返回
(boolean)
TSNode:named_child({index}) TSNode:named_child()
获取给定 {index} 处的节点的命名子节点,其中零代表第一个命名子节点。
参数
{index} (integer)
返回
(TSNode?)
TSNode:named_child_count() TSNode:named_child_count()
获取节点的命名子节点数量。
返回
(integer)
TSNode:named_descendant_for_range()
TSNode:named_descendant_for_range({start_row}, {start_col}, {end_row}, {end_col}) 获取此节点内跨越给定 (行,列) 位置范围的最小命名节点
参数
{start_row} (integer)
{start_col} (integer)
{end_row} (integer)
{end_col} (integer)
返回
(TSNode?)
TSNode:next_named_sibling() TSNode:next_named_sibling()
获取节点的下一个命名兄弟节点。
返回
(TSNode?)
TSNode:next_sibling() TSNode:next_sibling()
获取节点的下一个兄弟节点。
返回
(TSNode?)
TSNode:parent() TSNode:parent()
获取节点的直接父节点。建议使用 TSNode:child_with_descendant() 来迭代节点的祖先。
返回
(TSNode?)
TSNode:prev_named_sibling() TSNode:prev_named_sibling()
获取节点的上一个命名兄弟节点。
返回
(TSNode?)
TSNode:prev_sibling() TSNode:prev_sibling()
获取节点的上一个兄弟节点。
返回
(TSNode?)
TSNode:range({include_bytes}) TSNode:range()
获取节点的范围。
返回四个或六个值
开始行
开始列
开始字节(如果 {include_bytes}true
结束行
结束列
结束字节(如果 {include_bytes}true
参数
{include_bytes} (boolean?)
TSNode:sexpr() TSNode:sexpr()
获取表示节点的 S 表达式的字符串。
返回
(string)
TSNode:start() TSNode:start()
获取节点的起始位置。返回三个值:行、列和总字节数(均为从零开始)。
返回 (多个)
(integer) (integer) (integer)
TSNode:symbol() TSNode:symbol()
获取节点的类型作为数字 ID。
返回
(integer)
TSNode:tree() TSNode:tree()
获取节点的 TSTree
返回
(TSTree)
TSNode:type() TSNode:type()
获取节点的类型作为字符串。
返回
(string)

Lua 模块:vim.treesitter lua-treesitter-core

foldexpr({lnum}) vim.treesitter.foldexpr()
返回当前缓冲区中 {lnum} 的折叠级别。可以直接设置为 'foldexpr'
vim.wo.foldexpr = 'v:lua.vim.treesitter.foldexpr()'
属性
自:0.9.0
参数
{lnum} (integer?) 要计算折叠级别的行号
返回
(string)
vim.treesitter.get_captures_at_cursor()
get_captures_at_cursor({winnr}) 返回光标下方的突出显示捕获名称列表
参数
{winnr} (integer?) 窗口句柄或 0 代表当前窗口(默认)
返回
(string[]) 捕获名称列表
vim.treesitter.get_captures_at_pos()
get_captures_at_pos({bufnr}, {row}, {col}) 返回给定位置的突出显示捕获列表
每个捕获都由一个表表示,该表包含捕获名称(作为字符串)以及元数据表(priorityconceal 等;如果未定义,则为空)。
参数
{bufnr} (integer) 缓冲区编号(0 代表当前缓冲区)
{row} (integer) 位置行
{col} (integer) 位置列
返回
({capture: string, lang: string, metadata: vim.treesitter.query.TSMetadata}[])
get_node({opts}) vim.treesitter.get_node()
返回给定位置的最小命名节点
注意: 在未解析的树上调用此函数可能会生成无效的节点。如果树未被(例如,活动突出显示器)解析,请先通过以下方式解析树
vim.treesitter.get_parser(bufnr):parse(range)
参数
{opts} (table?) 可选关键字参数
{bufnr} (integer?) 缓冲区编号(nil 或 0 代表当前缓冲区)
{pos} ([integer, integer]?) 0 索引 (行,列) 元组。默认情况下,为当前窗口中的光标位置。如果 {bufnr} 不是当前缓冲区,则需要此参数。
{lang} (string?) 解析器语言。(默认:来自缓冲区文件类型)
{ignore_injections} (boolean?) 忽略注入的语言(默认 true)
{include_anonymous} (boolean?) 包含匿名节点(默认 false)
返回
(TSNode?) 给定位置的节点
get_node_range({node_or_range}) vim.treesitter.get_node_range()
返回节点的范围或解包的范围表
参数
{node_or_range} (TSNode|table) 节点或位置表
返回 (多个)
(integer) start_row (integer) start_col (integer) end_row (integer) end_col
vim.treesitter.get_node_text()
get_node_text({node}, {source}, {opts}) 获取与给定节点相对应的文本
参数
{node} (TSNode)
{source} (integer|string) 提取 {node} 的缓冲区或字符串
{opts} (table?) 可选参数。
metadata (table) 特定捕获的元数据。在使用 vim.treesitter.query.add_directive() 时,将其设置为 metadata[capture_id]
返回
(string)
get_parser({bufnr}, {lang}, {opts}) vim.treesitter.get_parser()
返回特定缓冲区的解析器并将其附加到该缓冲区
如果需要,这将创建解析器。
如果无法创建解析器,则会抛出错误。将 opts.error = false 设置为抑制此行为并返回 nil(以及错误消息)而不是抛出错误。 警告: 此行为将在 Nvim 0.12 中成为默认行为,并且该选项将被删除。
参数
{bufnr} (integer?) 解析器应绑定的缓冲区(默认:当前缓冲区)
{lang} (string?) 此解析器的语言(默认:来自缓冲区文件类型)
{opts} (table?) 传递给创建的语言树的选项
返回 (多个)
(vim.treesitter.LanguageTree?) 用于解析的对象 (string?) 错误消息(如果适用)
get_range({node}, {source}, {metadata}) vim.treesitter.get_range()
获取 TSNode 的范围。还可以提供 {source}{metadata} 来获取应用了指令的范围。
参数
{node} (TSNode)
{source} (integer|string?) 提取 {node} 的缓冲区或字符串
{metadata} (vim.treesitter.query.TSMetadata?)
返回
(table) 包含以下字段的表
{[1]} (integer) 开始行
{[2]} (integer) 开始列
{[3]} (integer) 开始字节
{[4]} (integer) 结束行
{[5]} (integer) 结束列
{[6]} (integer) 结束字节
vim.treesitter.get_string_parser()
get_string_parser({str}, {lang}, {opts}) 返回字符串解析器
参数
{str} (string) 要解析的文本
{lang} (string) 此字符串的语言
{opts} (table?) 传递给创建的语言树的选项
返回
(vim.treesitter.LanguageTree) 用于解析的对象
inspect_tree({opts}) vim.treesitter.inspect_tree()
打开一个窗口,显示语言树中节点的文本表示形式。
在窗口中,按 "a" 切换匿名节点的显示,按 "I" 切换每个节点的源语言的显示,按 "o" 切换查询编辑器,按 <Enter> 跳到源缓冲区中光标下的节点。折叠也可以使用(尝试 zozc 等)。
也可以使用 :InspectTree 显示。 :InspectTree
属性
自:0.9.0
参数
{opts} (table?) 可选选项表,包含以下可能的键
lang (字符串|nil): 源缓冲区的语言。如果省略,则从源缓冲区的文件类型检测。
bufnr (整数|nil): 用于绘制树的缓冲区。如果省略,则会创建一个新的缓冲区。
winid (整数|nil): 用于显示树缓冲区的窗口 ID。如果省略,则会使用 {command} 创建一个新窗口。
command (字符串|nil): 用于创建窗口的 Vimscript 命令。默认值为 "60vnew"。仅在 {winid} 为 nil 时使用。
title (字符串|fun(bufnr:整数):字符串|nil): 窗口的标题。如果为函数,则接受源缓冲区的缓冲区编号作为其唯一参数,并应返回一个字符串。
is_ancestor({dest}, {source}) vim.treesitter.is_ancestor()
确定一个节点是否另一个节点的祖先。
参数
{dest} (TSNode) 可能的祖先
{source} (TSNode) 可能的后代
返回
(布尔值) 如果 {dest}{source} 的祖先,则为真
vim.treesitter.is_in_node_range()
is_in_node_range({node}, {line}, {col}) 确定 (行, 列) 位置是否在节点范围内。
参数
{node} (TSNode) 定义范围
{line} (整数) 行 (从 0 开始)
{col} (整数) 列 (从 0 开始)
返回
(布尔值) 如果位置在节点范围内,则为真
node_contains({node}, {range}) vim.treesitter.node_contains()
确定一个节点是否包含一个范围。
参数
{node} (TSNode)
{range} ()
返回
(布尔值) 如果 {node} 包含 {range},则为真
start({bufnr}, {lang}) vim.treesitter.start()
为缓冲区启动树状语法高亮显示。
可以在 ftplugin 或 FileType autocommand 中使用。
注意: 默认情况下,禁用正则表达式语法高亮显示,这对于某些插件可能是必需的。在这种情况下,在调用 start 后添加 vim.bo.syntax = 'on'
示例
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
})
参数
{bufnr} (整数?) 要高亮显示的缓冲区 (默认值: 当前缓冲区)
{lang} (字符串?) 解析器的语言 (默认值: 来自缓冲区文件类型)
stop({bufnr}) vim.treesitter.stop()
停止为缓冲区进行树状语法高亮显示。
参数
{bufnr} (整数?) 要停止高亮显示的缓冲区 (默认值: 当前缓冲区)

Lua 模块: vim.treesitter.language lua-treesitter-language

add({lang}, {opts}) vim.treesitter.language.add()
加载名为 {lang} 的解析器。
解析器在 parser 运行时目录或提供的 {path} 中搜索。可以在启用树状语法功能之前用来检查可用的解析器,例如:
if vim.treesitter.language.add('markdown') then
  vim.treesitter.start(bufnr, 'markdown')
end
参数
{lang} (字符串) 解析器的名称 (仅限字母数字和 _)
{opts} (表?) 选项
{path} (字符串) 解析器所在的可选路径
{symbol_name} (字符串) 要加载的语言的内部符号名称
返回 (多个)
(布尔值?) 如果解析器已加载,则为真 (字符串?) 如果解析器无法加载,则为错误
get_filetypes({lang}) vim.treesitter.language.get_filetypes()
返回使用名为 {lang} 的解析器的文件类型。
该列表包括 {lang} 本身以及通过 vim.treesitter.language.register() 注册的所有文件类型。
参数
{lang} (字符串) 解析器的名称
返回
(字符串[]) 文件类型
get_lang({filetype}) vim.treesitter.language.get_lang()
返回加载 {filetype} 的解析器时要使用的语言名称。
如果未通过 vim.treesitter.language.register() 显式注册任何语言,则默认为 {filetype}。对于复合文件类型(如 html.glimmer),仅返回主文件类型。
参数
{filetype} (字符串)
返回
(字符串?)
inspect({lang}) vim.treesitter.language.inspect()
检查提供的语言。
检查提供有关语言的一些有用信息,例如节点和字段名称、ABI 版本以及语言是否来自 WASM 模块。
节点名称以一个表的形式返回,该表将每个节点名称映射到一个 布尔值,指示该节点是否被命名(即,不是匿名的)。匿名节点用双引号 (") 包围。
参数
{lang} (字符串) 语言
返回
()
register({lang}, {filetype}) vim.treesitter.language.register()
注册名为 {lang} 的解析器,用于 {filetype}
注意: 这会添加或覆盖 {filetype} 的映射,任何其他文件类型到 {lang} 的现有映射都将保留。
参数
{lang} (字符串) 解析器的名称
{filetype} (字符串|字符串[]) 与 lang 关联的文件类型

Lua 模块: vim.treesitter.query lua-treesitter-query

vim.treesitter.query.add_directive()
add_directive({name}, {handler}, {opts}) 添加一个新的指令,用于在查询中使用。
处理程序可以通过直接设置元数据对象 metadata.key = value 来设置匹配级别数据。此外,处理程序可以通过使用元数据表上的捕获 ID 来设置节点级别数据 metadata[capture_id].key = value
参数
{name} (字符串) 指令的名称,不带前导 #
{handler} (fun(match: table<integer,TSNode[]>, pattern: integer, source: integer|string, predicate: any[], metadata: vim.treesitter.query.TSMetadata))
match: 一个表,将捕获 ID 映射到捕获的节点列表
pattern: 查询文件中匹配模式的索引
predicate: 包含正在调用的完整指令的字符串列表,例如 (node (#set! conceal "-")) 将获得 { "#set!", "conceal", "-" } 的 predicate
{opts} () 具有以下字段的表
{force} (布尔值) 覆盖相同名称的现有 predicate
{all} (布尔值) 使用匹配表的正确实现,其中捕获 ID 映射到节点列表而不是单个节点。默认为 true。此选项将在将来的版本中删除。
vim.treesitter.query.add_predicate()
add_predicate({name}, {handler}, {opts}) 添加一个新的 predicate,用于在查询中使用。
参数
{name} (字符串) predicate 的名称,不带前导 #
{handler} (fun(match: table<integer,TSNode[]>, pattern: integer, source: integer|string, predicate: any[], metadata: vim.treesitter.query.TSMetadata): boolean?)
有关参数含义,请参阅 vim.treesitter.query.add_directive()
{opts} (表?) 具有以下字段的表
{force} (布尔值) 覆盖相同名称的现有 predicate
{all} (布尔值) 使用匹配表的正确实现,其中捕获 ID 映射到节点列表而不是单个节点。默认为 true。此选项将在将来的版本中删除。
edit({lang}) vim.treesitter.query.edit()
打开一个实时编辑器,用于查询你开始使用的缓冲区。
也可以使用 :EditQuery 显示。
如果你将光标移动到捕获名称 ("@foo"),则匹配捕获的文本将在源缓冲区中高亮显示。查询编辑器是一个临时缓冲区,使用 :write 保存它。你可以在 $VIMRUNTIME/queries/ 中找到查询示例。
参数
{lang} (字符串?) 要为其打开查询编辑器的语言。如果省略,则从当前缓冲区的文件类型推断。
get({lang}, {query_name}) vim.treesitter.query.get()
返回 {lang} 的运行时查询 {query_name}
参数
{lang} (字符串) 要用于查询的语言
{query_name} (字符串) 查询的名称 (例如 "highlights")
返回
(vim.treesitter.Query?) 已解析的查询。如果未找到任何查询文件,则为 nil
vim.treesitter.query.get_files()
get_files({lang}, {query_name}, {is_included}) 获取用于组成查询的文件列表
参数
{lang} (字符串) 要获取查询的语言
{query_name} (字符串) 要加载的查询的名称 (例如 "highlights")
{is_included} (布尔值?) 内部参数,大多数情况下保留为 nil
返回
(字符串[]) query_files 用于给定查询和语言的要加载的文件列表
lint({buf}, {opts}) vim.treesitter.query.lint()
使用已安装的解析器来 lint 树状语法查询,或清除 lint 错误。
使用 treesitter-parsers 在运行时路径中检查 {buf} 中的查询文件是否有错误。
验证使用的节点在语法中是否为有效标识符。
验证 predicate 和指令是否有效。
验证顶层 s-表达式是否有效。
使用 diagnostic-api 报告发现的诊断。默认情况下,用于验证的解析器由查询文件的包含文件夹确定,例如,如果路径以 /lua/highlights.scm 结尾,则将使用 lua 语言的解析器。
参数
{buf} (整数) 缓冲区句柄
{opts} (table?) 可选关键字参数
{langs} (字符串|字符串[]) 用于检查查询的语言。如果指定了多种语言,则会针对所有语言验证查询
{clear} (布尔值) 仅清除当前的 lint 错误
list_directives() vim.treesitter.query.list_directives()
列出当前可用的指令,用于在查询中使用。
返回
(字符串[]) 支持的指令。
list_predicates() vim.treesitter.query.list_predicates()
列出当前可用的 predicate,用于在查询中使用。
返回
(字符串[]) 支持的 predicate。
omnifunc({findstart}, {base}) vim.treesitter.query.omnifunc()
用于在树状语法查询中完成节点名称和 predicate 的 omnifunc。
通过以下方式使用
vim.bo.omnifunc = 'v:lua.vim.treesitter.query.omnifunc'
参数
{findstart} (0|1)
{base} (字符串)
parse({lang}, {query}) vim.treesitter.query.parse()
{query} 解析为字符串。 (如果查询在一个文件中,则调用者应在调用之前将内容读取到一个字符串中)。
返回一个 Query (参阅 lua-treesitter-query) 对象,可以使用该对象来搜索语法树中的节点,以查找使用 iter_capturesiter_matches 方法在 {query} 中定义的模式。
公开 infocaptures,其中包含有关 {query} 的更多上下文信息。
captures 包含在 {query} 中定义的唯一捕获名称列表。
info.captures 也指向 captures
info.patterns 包含有关 predicate 的信息。
参数
{lang} (字符串) 要用于查询的语言
{query} (字符串) s-expr 语法中的查询
返回
(vim.treesitter.Query) 已解析的查询
Query:iter_captures()
Query:iter_captures({node}, {source}, {start}, {stop}) 迭代 {node} 内所有匹配项中的所有捕获。
如果查询包含谓词,则需要 {source};在这种情况下,调用者必须确保使用与缓冲区当前文本一致的新解析的树(如果相关)。{start}{stop} 可用于限制行范围内的匹配项(这通常与根节点作为 {node} 一起使用,即获取当前视窗中的语法高亮匹配项)。如果省略,则使用给定节点的 {start}{stop} 行值。
迭代器返回四个值:用于识别捕获的数字 ID,捕获的节点,来自任何处理匹配的指令的元数据以及匹配本身。以下示例展示了如何按名称获取捕获
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
注意
只有当特定捕获的查询模式包含谓词时,才会返回捕获。
参数
{node} (TSNode) 将在其中进行搜索的节点
{source} (integer|string) 用于提取文本的源缓冲区或字符串
{start} (integer?) 搜索的起始行。默认为 node:start()
{stop} (integer?) 搜索的停止行(不包含末尾)。默认为 node:end_()
返回
(fun(end_line: integer?): integer, TSNode, vim.treesitter.query.TSMetadata, TSQueryMatch) 捕获 ID,捕获节点,元数据,匹配
Query:iter_matches()
Query:iter_matches({node}, {source}, {start}, {stop}, {opts}) 迭代给定范围内的自匹配项。
遍历 {node} 内的所有匹配项。参数与 Query:iter_captures() 相同,但迭代的值不同:查询中模式的(从 1 开始的)索引,一个将捕获索引映射到节点列表的表格,以及来自任何处理匹配的指令的元数据。
示例
for pattern, match, metadata in cquery:iter_matches(tree:root(), bufnr, 0, -1) 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
参数
{node} (TSNode) 将在其中进行搜索的节点
{source} (integer|string) 要搜索的源缓冲区或字符串
{start} (integer?) 搜索的起始行。默认为 node:start()
{stop} (integer?) 搜索的停止行(不包含末尾)。默认为 node:end_()
{opts} (table?) 可选关键字参数
max_start_depth (integer) 如果非零,则设置每个匹配项的最大起始深度。这用于防止遍历树的深度过深。
match_limit (integer) 设置正在进行的匹配的最大数量(默认值:256)。all (boolean) 当 false(默认值为 true)时,返回的表格将捕获 ID 映射到单个(最后一个)节点,而不是完整的匹配节点列表。此选项仅用于向后兼容性,将在将来的版本中移除。
返回
(fun(): integer, table<integer, TSNode[]>, vim.treesitter.query.TSMetadata) 模式 ID,匹配,元数据
set({lang}, {query_name}, {text}) vim.treesitter.query.set()
{lang} 设置名为 {query_name} 的运行时查询
这允许用户覆盖插件设置的任何运行时文件和/或配置。
参数
{lang} (字符串) 要用于查询的语言
{query_name} (string) 查询的名称(例如,“highlights”)
{text} (string) 查询文本(未解析)。

Lua 模块:vim.treesitter.languagetree lua-treesitter-languagetree

一个 LanguageTree 包含解析器的树:{lang} 的根树状解析器以及任何“注入”的语言解析器,这些解析器本身可能会递归地注入其他语言。例如,包含一些 Vimscript 命令的 Lua 缓冲区需要多个解析器才能完全理解其内容。
要为给定缓冲区和语言创建 LanguageTree(解析器对象),请使用
local parser = vim.treesitter.get_parser(bufnr, lang)
(其中 bufnr=0 表示当前缓冲区)。lang 默认为 'filetype'注意:目前,解析器保留在缓冲区的整个生命周期内,但这可能会改变;如果插件想要增量更新,它应该保留对解析器对象的引用。
每当您需要访问当前语法树时,请解析缓冲区
local tree = parser:parse({ start_row, end_row })
这将返回一个表示缓冲区当前状态的不可变 treesitter-tree 对象的表格。当插件想要访问(可能)编辑后的状态时,它必须再次调用 parse()。如果缓冲区没有被编辑,则将再次返回相同的树,无需额外工作。如果缓冲区之前已被解析,则将对更改的部分进行增量解析。
注意:要在 nvim_buf_attach() Lua 回调中直接使用解析器,您必须在注册回调之前调用 vim.treesitter.get_parser()。但最好不要在更改回调中直接进行解析,因为它们会非常频繁。相反,对树进行任何类型分析的插件应该使用计时器来限制过于频繁的更新。
LanguageTree:children() LanguageTree:children()
返回一个语言到子树的映射。
LanguageTree:contains({range}) LanguageTree:contains()
确定 {range} 是否包含在 LanguageTree 中。
参数
{range} (table) 一个具有以下字段的表格
{[1]} (integer) 开始行
{[2]} (integer) 开始列
{[3]} (integer) 结束行
{[4]} (integer) 结束列
返回
(boolean)
LanguageTree:destroy() LanguageTree:destroy()
销毁此 LanguageTree 及其所有子节点。
任何清理逻辑都应该在这里执行。
注意:这不会从父节点中删除此树。相反,必须在父节点上调用 remove_child 来删除它。
LanguageTree:for_each_tree({fn}) LanguageTree:for_each_tree()
递归地为每个 LanguageTree 调用回调。
注意:这还包括调用树的子树。
参数
{fn} (fun(tree: TSTree, ltree: vim.treesitter.LanguageTree))
LanguageTree:included_regions() LanguageTree:included_regions()
获取此 LanguageTree 管理的包含区域集。这可能与注入查询设置的区域不同,因为部分 LanguageTree:parse() 会删除请求范围之外的区域。每个列表都表示一个范围,形式为 { {start_row}, {start_col}, {start_bytes}, {end_row}, {end_col}, {end_bytes} }。
返回
(table<integer, Range6[]>)
LanguageTree:invalidate({reload}) LanguageTree:invalidate()
使此解析器及其子节点失效。
仅当 LanguageTree 的跟踪状态与树状解析器中的解析树不匹配时才应该调用。不会清除文件系统缓存。经常被调用,因此需要很快。
参数
{reload} (boolean?)
LanguageTree:is_valid({exclude_children}) LanguageTree:is_valid()
返回此 LanguageTree 是否有效,即 LanguageTree:trees() 是否反映了源的最新状态。如果无效,用户应该调用 LanguageTree:parse()
参数
{exclude_children} (boolean?) 是否忽略子节点的有效性(默认值为 false
返回
(boolean)
LanguageTree:lang() LanguageTree:lang()
获取此树节点的语言。
LanguageTree:language_for_range()
LanguageTree:language_for_range({range}) 获取包含 {range} 的适当语言。
参数
{range} (table) 一个具有以下字段的表格
{[1]} (integer) 开始行
{[2]} (integer) 开始列
{[3]} (integer) 结束行
{[4]} (integer) 结束列
返回
(vim.treesitter.LanguageTree) 管理 {range} 的树
LanguageTree:named_node_for_range()
LanguageTree:named_node_for_range({range}, {opts}) 获取包含 {range} 的最小命名节点。
参数
{range} (table) 一个具有以下字段的表格
{[1]} (integer) 开始行
{[2]} (integer) 开始列
{[3]} (integer) 结束行
{[4]} (integer) 结束列
{opts} (表?) 具有以下字段的表
{ignore_injections} (boolean, default: true) 忽略注入的语言
返回
(TSNode?)
LanguageTree:node_for_range()
LanguageTree:node_for_range({range}, {opts}) 获取包含 {range} 的最小节点。
参数
{range} (table) 一个具有以下字段的表格
{[1]} (integer) 开始行
{[2]} (integer) 开始列
{[3]} (integer) 结束行
{[4]} (integer) 结束列
{opts} (表?) 具有以下字段的表
{ignore_injections} (boolean, default: true) 忽略注入的语言
返回
(TSNode?)
LanguageTree:parse({range}) LanguageTree:parse()
使用 treesitter-parsers 为相应的语言递归解析语言树中的所有区域,并在解析后的树上运行注入查询以确定是否应该创建和解析子树。
任何具有空范围({},通常只有根树)的区域总是被解析;否则(通常是注入)只有在它与 {range} 相交时(或者如果 {range}true)才会被解析。
参数
{range} (boolean|Range?) 解析解析器源中的此范围。设置为 true 以对源进行完全解析(注意:可能会很慢!)设置为 false|nil 仅解析具有空范围的区域(通常只有没有注入的根树)。
返回
(table<integer, TSTree>)
LanguageTree:register_cbs()
LanguageTree:register_cbs({cbs}, {recursive}) 为 LanguageTree 注册回调。
参数
{cbs} (table<TSCallbackNameOn,function>) 一个类似于 nvim_buf_attach() 的表格参数,具有以下处理程序
on_bytes : 见 nvim_buf_attach(),但这将在解析器回调之后被调用。
on_changedtree : 每当树发生语法变化时,都会调用一个回调。它将传递两个参数:一个包含发生变化的范围(作为节点范围)的表格以及发生变化的树。
on_child_added : 当子节点被添加到树中时发出。
on_child_removed : 当子节点从树中移除时发出。
on_detach : 当缓冲区被分离时发出,参见 nvim_buf_detach_event。接受一个参数,即缓冲区的编号。
{recursive} (boolean?) 递归地为所有子节点应用回调。任何新的子节点也将继承这些回调。
LanguageTree:source() LanguageTree:source()
返回语言树的源内容(bufnr 或字符串)。
LanguageTree:tree_for_range()
LanguageTree:tree_for_range({range}, {opts}) 获取包含 {range} 的树。
参数
{range} (table) 一个具有以下字段的表格
{[1]} (integer) 开始行
{[2]} (integer) 开始列
{[3]} (integer) 结束行
{[4]} (integer) 结束列
{opts} (表?) 具有以下字段的表
{ignore_injections} (boolean, default: true) 忽略注入的语言
返回
(TSTree?)
LanguageTree:trees() LanguageTree:trees()
返回此解析器解析的区域的所有树。不包括子语言。如果结果是列表状的,则
此 LanguageTree 是根节点,在这种情况下,结果为空或是一个单元素列表;或者
根 LanguageTree 被完全解析。
返回
(table<integer, TSTree>)
命令索引
快速参考