├── LICENSE ├── Makefile ├── README.md ├── plugin └── nvim-treesitter-rescript.vim ├── queries └── rescript │ ├── highlights.scm │ ├── injections.scm │ ├── locals.scm │ └── textobjects.scm └── tree-sitter-rescript ├── Cargo.toml ├── binding.gyp ├── bindings ├── node │ ├── binding.cc │ └── index.js └── rust │ ├── build.rs │ └── lib.rs ├── grammar.js └── src ├── grammar.json ├── node-types.json ├── parser.c ├── scanner.c └── tree_sitter └── parser.h /LICENSE: -------------------------------------------------------------------------------- 1 | The MIT License (MIT) 2 | 3 | Copyright (c) 2021 Victor Nakoryakov 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /Makefile: -------------------------------------------------------------------------------- 1 | 2 | .PHONY: pull 3 | pull: 4 | @if [ -z "$${TS_RESCRIPT_DIR}" ]; then \ 5 | echo "Environment variable TS_RESCRIPT_DIR not set"; \ 6 | exit 1; \ 7 | fi 8 | cp -R ${TS_RESCRIPT_DIR}/{binding.gyp,Cargo.toml,grammar.js,bindings/,src/} tree-sitter-rescript/ 9 | cp ${TS_RESCRIPT_DIR}/queries/* queries/rescript/ 10 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # ReScript parser for nvim-treesitter 2 | 3 | This repository contains a thin wrapper around [ReScript parser for Tree-sitter](https://github.com/nkrkv/tree-sitter-rescript/) to make it an easy-to-install NeoVim plugin. 4 | 5 | ## Requirements 6 | 7 | - NeoVim 0.5.0+ 8 | - Installed and configured [`nvim-treesitter`](https://github.com/nvim-treesitter/nvim-treesitter) plugin 9 | 10 | ## Installation 11 | 12 | Add the plugin in your `init.vim`: 13 | 14 | ```vim 15 | Plug 'nkrkv/nvim-treesitter-rescript' 16 | ``` 17 | 18 | or using [packer.nvim](https://github.com/wbthomason/packer.nvim): 19 | 20 | ```lua 21 | use 'nkrkv/nvim-treesitter-rescript' 22 | ``` 23 | 24 | Install the newly available parser: 25 | 26 | ``` 27 | :TSInstall rescript 28 | ``` 29 | 30 | ## Contributing 31 | 32 | This is a technical repo containing a copy of the upstream [ReScript parser for Tree-sitter](https://github.com/nkrkv/tree-sitter-rescript/). Please, open issues and PR’s there. Unless the problem is indeed related to the plugin wrapping. 33 | -------------------------------------------------------------------------------- /plugin/nvim-treesitter-rescript.vim: -------------------------------------------------------------------------------- 1 | if exists('g:loaded_nvim_treesitter_rescript') 2 | finish 3 | endif 4 | 5 | lua <:p:h:h") 7 | require"nvim-treesitter.parsers".get_parser_configs().rescript = { 8 | install_info = { 9 | -- point to local copy of the `tree-sitter-rescript` parser 10 | url = plugin_dir .. "/tree-sitter-rescript", 11 | files = {"src/parser.c", "src/scanner.c"} 12 | }, 13 | filetype = "rescript", 14 | } 15 | EOF 16 | 17 | let g:loaded_nvim_treesitter_rescript = 1 18 | -------------------------------------------------------------------------------- /queries/rescript/highlights.scm: -------------------------------------------------------------------------------- 1 | (comment) @comment 2 | 3 | ; Identifiers 4 | ;------------ 5 | 6 | ; Escaped identifiers like \"+." 7 | ((value_identifier) @constant.macro 8 | (#match? @constant.macro "^\\.*$")) 9 | 10 | [ 11 | (type_identifier) 12 | (unit_type) 13 | (list) 14 | (list_pattern) 15 | ] @type 16 | 17 | [ 18 | (variant_identifier) 19 | (polyvar_identifier) 20 | ] @constant 21 | 22 | (record_type_field (property_identifier) @property) 23 | (record_field (property_identifier) @property) 24 | (object (field (property_identifier) @property)) 25 | (object_type (field (property_identifier) @property)) 26 | (member_expression (property_identifier) @property) 27 | (module_identifier) @namespace 28 | 29 | ; Parameters 30 | ;---------------- 31 | 32 | (list_pattern (value_identifier) @parameter) 33 | (spread_pattern (value_identifier) @parameter) 34 | 35 | ; String literals 36 | ;---------------- 37 | 38 | [ 39 | (string) 40 | (template_string) 41 | ] @string 42 | 43 | (template_substitution 44 | "${" @punctuation.bracket 45 | "}" @punctuation.bracket) @embedded 46 | 47 | (character) @string.special 48 | (escape_sequence) @string.escape 49 | 50 | ; Other literals 51 | ;--------------- 52 | 53 | [ 54 | (true) 55 | (false) 56 | ] @constant.builtin 57 | 58 | (number) @number 59 | (polyvar) @constant 60 | (polyvar_string) @constant 61 | 62 | ; Functions 63 | ;---------- 64 | 65 | ; parameter(s) in parens 66 | [ 67 | (parameter (value_identifier)) 68 | (labeled_parameter (value_identifier)) 69 | ] @parameter 70 | 71 | ; single parameter with no parens 72 | (function parameter: (value_identifier) @parameter) 73 | 74 | ; first-level descructuring (required for nvim-tree-sitter as it only matches direct 75 | ; children and the above patterns do not match destructuring patterns in NeoVim) 76 | (parameter (tuple_pattern (tuple_item_pattern (value_identifier) @parameter))) 77 | (parameter (array_pattern (value_identifier) @parameter)) 78 | (parameter (record_pattern (value_identifier) @parameter)) 79 | 80 | ; Meta 81 | ;----- 82 | 83 | [ 84 | "@" 85 | "@@" 86 | (decorator_identifier) 87 | ] @annotation 88 | 89 | (extension_identifier) @keyword 90 | ("%") @keyword 91 | 92 | ; Misc 93 | ;----- 94 | 95 | (subscript_expression index: (string) @property) 96 | (polyvar_type_pattern "#" @constant) 97 | 98 | [ 99 | ("include") 100 | ("open") 101 | ] @include 102 | 103 | [ 104 | "as" 105 | "export" 106 | "external" 107 | "let" 108 | "module" 109 | "mutable" 110 | "private" 111 | "rec" 112 | "type" 113 | "and" 114 | "assert" 115 | "await" 116 | "with" 117 | "unpack" 118 | "lazy" 119 | "constraint" 120 | ] @keyword 121 | 122 | ((function "async" @keyword)) 123 | 124 | [ 125 | "if" 126 | "else" 127 | "switch" 128 | "when" 129 | ] @conditional 130 | 131 | [ 132 | "exception" 133 | "try" 134 | "catch" 135 | ] @exception 136 | 137 | (call_expression 138 | function: (value_identifier) @exception 139 | (#eq? @exception "raise")) 140 | 141 | [ 142 | "for" 143 | "in" 144 | "to" 145 | "downto" 146 | "while" 147 | ] @repeat 148 | 149 | [ 150 | "." 151 | "," 152 | "|" 153 | ] @punctuation.delimiter 154 | 155 | [ 156 | "++" 157 | "+" 158 | "+." 159 | "-" 160 | "-." 161 | "*" 162 | "**" 163 | "*." 164 | "/." 165 | "<=" 166 | "==" 167 | "===" 168 | "!" 169 | "!=" 170 | "!==" 171 | ">=" 172 | "&&" 173 | "||" 174 | "=" 175 | ":=" 176 | "->" 177 | "|>" 178 | ":>" 179 | "+=" 180 | (uncurry) 181 | ] @operator 182 | 183 | ; Explicitly enclose these operators with binary_expression 184 | ; to avoid confusion with JSX tag delimiters 185 | (binary_expression ["<" ">" "/"] @operator) 186 | 187 | [ 188 | "(" 189 | ")" 190 | "{" 191 | "}" 192 | "[" 193 | "]" 194 | ] @punctuation.bracket 195 | 196 | (polyvar_type 197 | [ 198 | "[" 199 | "[>" 200 | "[<" 201 | "]" 202 | ] @punctuation.bracket) 203 | 204 | [ 205 | "~" 206 | "?" 207 | "=>" 208 | ".." 209 | "..." 210 | ] @punctuation.special 211 | 212 | (ternary_expression ["?" ":"] @operator) 213 | 214 | ; JSX 215 | ;---------- 216 | (jsx_identifier) @tag 217 | (jsx_element 218 | open_tag: (jsx_opening_element ["<" ">"] @tag.delimiter)) 219 | (jsx_element 220 | close_tag: (jsx_closing_element ["<" "/" ">"] @tag.delimiter)) 221 | (jsx_self_closing_element ["/" ">" "<"] @tag.delimiter) 222 | (jsx_fragment [">" "<" "/"] @tag.delimiter) 223 | (jsx_attribute (property_identifier) @tag.attribute) 224 | 225 | ; Error 226 | ;---------- 227 | 228 | (ERROR) @error 229 | -------------------------------------------------------------------------------- /queries/rescript/injections.scm: -------------------------------------------------------------------------------- 1 | (comment) @comment 2 | 3 | ; %re 4 | (extension_expression 5 | (extension_identifier) @_name 6 | (#eq? @_name "re") 7 | (expression_statement (_) @regex)) 8 | 9 | ; %raw 10 | (extension_expression 11 | (extension_identifier) @_name 12 | (#eq? @_name "raw") 13 | (expression_statement 14 | (_ (_) @javascript))) 15 | 16 | ; %graphql 17 | (extension_expression 18 | (extension_identifier) @_name 19 | (#eq? @_name "graphql") 20 | (expression_statement 21 | (_ (_) @graphql))) 22 | -------------------------------------------------------------------------------- /queries/rescript/locals.scm: -------------------------------------------------------------------------------- 1 | (switch_expression) @scope 2 | 3 | ; Definitions 4 | ;------------ 5 | (type_declaration) @definition.type 6 | (let_binding) @definition.var 7 | (module_declaration) @definition.namespace 8 | -------------------------------------------------------------------------------- /queries/rescript/textobjects.scm: -------------------------------------------------------------------------------- 1 | ; Queries for nvim-treesitter/nvim-treesitter-textobjects 2 | ;-------------------------------------------------------- 3 | 4 | ; Classes (modules) 5 | ;------------------ 6 | 7 | (module_binding definition: ((_) @class.inner)) @class.outer 8 | 9 | ; Blocks 10 | ;------- 11 | 12 | (block (_) @block.inner) @block.outer 13 | 14 | ; Functions 15 | ;---------- 16 | 17 | (function body: (_) @function.inner) @function.outer 18 | 19 | ; Calls 20 | ;------ 21 | 22 | (call_expression arguments: ((_) @call.inner)) @call.outer 23 | 24 | ; Comments 25 | ;--------- 26 | 27 | (comment) @comment.outer 28 | 29 | ; Parameters 30 | ;----------- 31 | 32 | (function parameter: (_) @parameter.inner @parameter.outer) 33 | 34 | (formal_parameters 35 | "," @_formal_parameters_start 36 | . (_) @parameter.inner 37 | (#make-range! "parameter.outer" @_formal_parameters_start @parameter.inner)) 38 | (formal_parameters 39 | . (_) @parameter.inner 40 | . ","? @_formal_parameters_end 41 | (#make-range! "parameter.outer" @parameter.inner @_formal_parameters_end)) 42 | 43 | (arguments 44 | "," @_arguments_start 45 | . (_) @parameter.inner 46 | (#make-range! "parameter.outer" @_arguments_start @parameter.inner)) 47 | (arguments 48 | . (_) @parameter.inner 49 | . ","? @_arguments_end 50 | (#make-range! "parameter.outer" @parameter.inner @_arguments_end)) 51 | 52 | (function_type_parameters 53 | "," @_function_type_parameters_start 54 | . (_) @parameter.inner 55 | (#make-range! "parameter.outer" @_function_type_parameters_start @parameter.inner)) 56 | (function_type_parameters 57 | . (_) @parameter.inner 58 | . ","? @_function_type_parameters_end 59 | (#make-range! "parameter.outer" @parameter.inner @_function_type_parameters_end)) 60 | 61 | (functor_parameters 62 | "," @_functor_parameters_start 63 | . (_) @parameter.inner 64 | (#make-range! "parameter.outer" @_functor_parameters_start @parameter.inner)) 65 | (functor_parameters 66 | . (_) @parameter.inner 67 | . ","? @_functor_parameters_end 68 | (#make-range! "parameter.outer" @parameter.inner @_functor_parameters_end)) 69 | 70 | (type_parameters 71 | "," @_type_parameters_start 72 | . (_) @parameter.inner 73 | (#make-range! "parameter.outer" @_type_parameters_start @parameter.inner)) 74 | (type_parameters 75 | . (_) @parameter.inner 76 | . ","? @_type_parameters_end 77 | (#make-range! "parameter.outer" @parameter.inner @_type_parameters_end)) 78 | 79 | (type_arguments 80 | "," @_type_arguments_start 81 | . (_) @parameter.inner 82 | (#make-range! "parameter.outer" @_type_arguments_start @parameter.inner)) 83 | (type_arguments 84 | . (_) @parameter.inner 85 | . ","? @_type_arguments_end 86 | (#make-range! "parameter.outer" @parameter.inner @_type_arguments_end)) 87 | 88 | (decorator_arguments 89 | "," @_decorator_arguments_start 90 | . (_) @parameter.inner 91 | (#make-range! "parameter.outer" @_decorator_arguments_start @parameter.inner)) 92 | (decorator_arguments 93 | . (_) @parameter.inner 94 | . ","? @_arguments_end 95 | (#make-range! "parameter.outer" @parameter.inner @_arguments_end)) 96 | 97 | (variant_parameters 98 | "," @_variant_parameters_start 99 | . (_) @parameter.inner 100 | (#make-range! "parameter.outer" @_variant_parameters_start @parameter.inner)) 101 | (variant_parameters 102 | . (_) @parameter.inner 103 | . ","? @_variant_parameters_end 104 | (#make-range! "parameter.outer" @parameter.inner @_variant_parameters_end)) 105 | 106 | (polyvar_parameters 107 | "," @_polyvar_parameters_start 108 | . (_) @parameter.inner 109 | (#make-range! "parameter.outer" @_polyvar_parameters_start @parameter.inner)) 110 | (polyvar_parameters 111 | . (_) @parameter.inner 112 | . ","? @_polyvar_parameters_end 113 | (#make-range! "parameter.outer" @parameter.inner @_polyvar_parameters_end)) 114 | 115 | -------------------------------------------------------------------------------- /tree-sitter-rescript/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "tree-sitter-rescript" 3 | description = "rescript grammar for the tree-sitter parsing library" 4 | version = "0.0.1" 5 | keywords = ["incremental", "parsing", "rescript"] 6 | categories = ["parsing", "text-editors"] 7 | repository = "https://github.com/tree-sitter/tree-sitter-rescript" 8 | edition = "2018" 9 | license = "MIT" 10 | 11 | build = "bindings/rust/build.rs" 12 | include = [ 13 | "bindings/rust/*", 14 | "grammar.js", 15 | "queries/*", 16 | "src/*", 17 | ] 18 | 19 | [lib] 20 | path = "bindings/rust/lib.rs" 21 | 22 | [dependencies] 23 | tree-sitter = "~0.20.0" 24 | 25 | [build-dependencies] 26 | cc = "1.0" 27 | -------------------------------------------------------------------------------- /tree-sitter-rescript/binding.gyp: -------------------------------------------------------------------------------- 1 | { 2 | "targets": [ 3 | { 4 | "target_name": "tree_sitter_rescript_binding", 5 | "include_dirs": [ 6 | " 3 | #include "nan.h" 4 | 5 | using namespace v8; 6 | 7 | extern "C" TSLanguage * tree_sitter_rescript(); 8 | 9 | namespace { 10 | 11 | NAN_METHOD(New) {} 12 | 13 | void Init(Local exports, Local module) { 14 | Local tpl = Nan::New(New); 15 | tpl->SetClassName(Nan::New("Language").ToLocalChecked()); 16 | tpl->InstanceTemplate()->SetInternalFieldCount(1); 17 | 18 | Local constructor = Nan::GetFunction(tpl).ToLocalChecked(); 19 | Local instance = constructor->NewInstance(Nan::GetCurrentContext()).ToLocalChecked(); 20 | Nan::SetInternalFieldPointer(instance, 0, tree_sitter_rescript()); 21 | 22 | Nan::Set(instance, Nan::New("name").ToLocalChecked(), Nan::New("rescript").ToLocalChecked()); 23 | Nan::Set(module, Nan::New("exports").ToLocalChecked(), instance); 24 | } 25 | 26 | NODE_MODULE(tree_sitter_rescript_binding, Init) 27 | 28 | } // namespace 29 | -------------------------------------------------------------------------------- /tree-sitter-rescript/bindings/node/index.js: -------------------------------------------------------------------------------- 1 | try { 2 | module.exports = require("../../build/Release/tree_sitter_rescript_binding"); 3 | } catch (error1) { 4 | if (error1.code !== 'MODULE_NOT_FOUND') { 5 | throw error1; 6 | } 7 | try { 8 | module.exports = require("../../build/Debug/tree_sitter_rescript_binding"); 9 | } catch (error2) { 10 | if (error2.code !== 'MODULE_NOT_FOUND') { 11 | throw error2; 12 | } 13 | throw error1 14 | } 15 | } 16 | 17 | try { 18 | module.exports.nodeTypeInfo = require("../../src/node-types.json"); 19 | } catch (_) {} 20 | -------------------------------------------------------------------------------- /tree-sitter-rescript/bindings/rust/build.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let src_dir = std::path::Path::new("src"); 3 | 4 | let mut c_config = cc::Build::new(); 5 | c_config.include(&src_dir); 6 | c_config 7 | .flag_if_supported("-Wno-unused-parameter") 8 | .flag_if_supported("-Wno-unused-but-set-variable") 9 | .flag_if_supported("-Wno-trigraphs"); 10 | let parser_path = src_dir.join("parser.c"); 11 | c_config.file(&parser_path); 12 | 13 | // If your language uses an external scanner written in C, 14 | // then include this block of code: 15 | 16 | /* 17 | let scanner_path = src_dir.join("scanner.c"); 18 | c_config.file(&scanner_path); 19 | println!("cargo:rerun-if-changed={}", scanner_path.to_str().unwrap()); 20 | */ 21 | 22 | c_config.compile("parser"); 23 | println!("cargo:rerun-if-changed={}", parser_path.to_str().unwrap()); 24 | 25 | // If your language uses an external scanner written in C++, 26 | // then include this block of code: 27 | 28 | /* 29 | let mut cpp_config = cc::Build::new(); 30 | cpp_config.cpp(true); 31 | cpp_config.include(&src_dir); 32 | cpp_config 33 | .flag_if_supported("-Wno-unused-parameter") 34 | .flag_if_supported("-Wno-unused-but-set-variable"); 35 | let scanner_path = src_dir.join("scanner.cc"); 36 | cpp_config.file(&scanner_path); 37 | cpp_config.compile("scanner"); 38 | println!("cargo:rerun-if-changed={}", scanner_path.to_str().unwrap()); 39 | */ 40 | } 41 | -------------------------------------------------------------------------------- /tree-sitter-rescript/bindings/rust/lib.rs: -------------------------------------------------------------------------------- 1 | //! This crate provides rescript language support for the [tree-sitter][] parsing library. 2 | //! 3 | //! Typically, you will use the [language][language func] function to add this language to a 4 | //! tree-sitter [Parser][], and then use the parser to parse some code: 5 | //! 6 | //! ``` 7 | //! let code = ""; 8 | //! let mut parser = tree_sitter::Parser::new(); 9 | //! parser.set_language(tree_sitter_rescript::language()).expect("Error loading rescript grammar"); 10 | //! let tree = parser.parse(code, None).unwrap(); 11 | //! ``` 12 | //! 13 | //! [Language]: https://docs.rs/tree-sitter/*/tree_sitter/struct.Language.html 14 | //! [language func]: fn.language.html 15 | //! [Parser]: https://docs.rs/tree-sitter/*/tree_sitter/struct.Parser.html 16 | //! [tree-sitter]: https://tree-sitter.github.io/ 17 | 18 | use tree_sitter::Language; 19 | 20 | extern "C" { 21 | fn tree_sitter_rescript() -> Language; 22 | } 23 | 24 | /// Get the tree-sitter [Language][] for this grammar. 25 | /// 26 | /// [Language]: https://docs.rs/tree-sitter/*/tree_sitter/struct.Language.html 27 | pub fn language() -> Language { 28 | unsafe { tree_sitter_rescript() } 29 | } 30 | 31 | /// The content of the [`node-types.json`][] file for this grammar. 32 | /// 33 | /// [`node-types.json`]: https://tree-sitter.github.io/tree-sitter/using-parsers#static-node-types 34 | pub const NODE_TYPES: &'static str = include_str!("../../src/node-types.json"); 35 | 36 | // Uncomment these to include any queries that this grammar contains 37 | 38 | // pub const HIGHLIGHTS_QUERY: &'static str = include_str!("../../queries/highlights.scm"); 39 | // pub const INJECTIONS_QUERY: &'static str = include_str!("../../queries/injections.scm"); 40 | // pub const LOCALS_QUERY: &'static str = include_str!("../../queries/locals.scm"); 41 | // pub const TAGS_QUERY: &'static str = include_str!("../../queries/tags.scm"); 42 | 43 | #[cfg(test)] 44 | mod tests { 45 | #[test] 46 | fn test_can_load_grammar() { 47 | let mut parser = tree_sitter::Parser::new(); 48 | parser 49 | .set_language(super::language()) 50 | .expect("Error loading rescript language"); 51 | } 52 | } 53 | -------------------------------------------------------------------------------- /tree-sitter-rescript/grammar.js: -------------------------------------------------------------------------------- 1 | module.exports = grammar({ 2 | name: 'rescript', 3 | 4 | externals: $ => [ 5 | $._newline, 6 | $.comment, 7 | $._newline_and_comment, 8 | '"', 9 | "`", 10 | $._template_chars, 11 | $._lparen, 12 | $._rparen, 13 | $._list_constructor 14 | ], 15 | 16 | extras: $ => [ 17 | $.comment, 18 | /[\s\uFEFF\u2060\u200B\u00A0]/ 19 | ], 20 | 21 | supertypes: $ => [ 22 | $.statement, 23 | $.declaration, 24 | $.expression, 25 | $.primary_expression, 26 | $._type, 27 | $.module_expression, 28 | $.module_primary_expression, 29 | ], 30 | 31 | inline: $ => [ 32 | $._module_definition, 33 | ], 34 | 35 | precedences: $ => [ 36 | // + - Operators -> precendence 37 | [ 38 | 'unary_not', 39 | 'member', 40 | 'call', 41 | $.spread_element, 42 | $.await_expression, 43 | $.pipe_expression, 44 | $.lazy_expression, 45 | 'binary_times', 46 | 'binary_pow', 47 | 'binary_plus', 48 | 'binary_compare', 49 | 'binary_relation', 50 | 'binary_and', 51 | 'binary_or', 52 | 'coercion_relation', 53 | $.expression, 54 | $.primary_expression, 55 | $.ternary_expression, 56 | $.mutation_expression, 57 | $.function, 58 | $.let_declaration, 59 | ], 60 | // Nested.Module.Path precendence 61 | [ 62 | $.module_primary_expression, 63 | $.value_identifier_path, 64 | $.nested_variant_identifier, 65 | $.module_identifier_path, 66 | ], 67 | [$._jsx_attribute_value, $.pipe_expression], 68 | [$.function_type_parameters, $.function_type], 69 | ], 70 | 71 | conflicts: $ => [ 72 | [$.unit, $.formal_parameters], 73 | [$.primary_expression, $._pattern], 74 | [$.primary_expression, $.record_pattern], 75 | [$.primary_expression, $.spread_pattern], 76 | [$.primary_expression, $._literal_pattern], 77 | [$.primary_expression, $.lazy_pattern], 78 | [$.primary_expression, $._jsx_child], 79 | [$.tuple_pattern, $.parameter], 80 | [$.primary_expression, $.parameter], 81 | [$.primary_expression, $.record_field], 82 | [$.tuple_type, $.function_type_parameter], 83 | [$.list, $.list_pattern], 84 | [$.array, $.array_pattern], 85 | [$.record_field, $.record_pattern], 86 | [$.expression_statement, $.ternary_expression], 87 | [$.type_declaration], 88 | [$.type_binding], 89 | [$.let_declaration], 90 | [$.let_declaration, $.ternary_expression], 91 | [$.variant_identifier, $.module_identifier], 92 | [$.variant, $.variant_pattern], 93 | [$.variant_declaration, $.function_type_parameter], 94 | [$.variant_arguments, $._variant_pattern_parameters], 95 | [$.polyvar, $.polyvar_pattern], 96 | [$._pattern], 97 | [$._record_element, $.jsx_expression], 98 | [$._record_element, $._record_single_field], 99 | [$._record_pun_field, $._record_single_pun_field], 100 | [$._record_field_name, $.record_pattern], 101 | [$.decorator], 102 | [$._statement, $._one_or_more_statements], 103 | [$._inline_type, $.function_type_parameters], 104 | [$.primary_expression, $.parameter, $._pattern], 105 | [$.parameter, $._pattern], 106 | [$.parameter, $.parenthesized_pattern], 107 | [$.parameter, $.tuple_item_pattern], 108 | [$.variant_declaration], 109 | [$.unit, $._function_type_parameter_list], 110 | [$.functor_parameter, $.module_primary_expression, $.module_identifier_path], 111 | [$._reserved_identifier, $.function], 112 | [$.polyvar_type], 113 | [$.let_binding, $.or_pattern], 114 | [$.exception_pattern, $.or_pattern], 115 | [$.type_binding, $._inline_type] 116 | ], 117 | 118 | rules: { 119 | source_file: $ => seq( 120 | repeat($._statement_delimeter), 121 | repeat($._statement) 122 | ), 123 | 124 | _statement: $ => seq( 125 | $.statement, 126 | repeat1($._statement_delimeter) 127 | ), 128 | 129 | _statement_delimeter: $ => choice( 130 | ';', 131 | $._newline, 132 | alias($._newline_and_comment, $.comment), 133 | ), 134 | 135 | _one_or_more_statements: $ => seq( 136 | repeat($._statement), 137 | $.statement, 138 | optional($._statement_delimeter), 139 | ), 140 | 141 | statement: $ => choice( 142 | alias($._decorated_statement, $.decorated), 143 | $.decorator_statement, 144 | $.expression_statement, 145 | $.declaration, 146 | $.open_statement, 147 | $.include_statement, 148 | ), 149 | 150 | _decorated_statement: $ => seq( 151 | repeat1($.decorator), 152 | choice( 153 | $.declaration, 154 | $.expression_statement 155 | ) 156 | ), 157 | 158 | decorator_statement: $ => seq( 159 | '@@', 160 | $.decorator_identifier, 161 | optional($.decorator_arguments) 162 | ), 163 | 164 | block: $ => prec.right(seq( 165 | '{', 166 | optional($._one_or_more_statements), 167 | '}', 168 | )), 169 | 170 | open_statement: $ => seq( 171 | 'open', 172 | optional('!'), 173 | $.module_expression, 174 | ), 175 | 176 | include_statement: $ => seq( 177 | 'include', 178 | $.module_expression, 179 | ), 180 | 181 | declaration: $ => choice( 182 | $.type_declaration, 183 | $.let_declaration, 184 | $.module_declaration, 185 | $.external_declaration, 186 | $.exception_declaration, 187 | ), 188 | 189 | module_binding: $ => prec.left(seq( 190 | field('name', choice($.module_identifier, $.type_identifier)), 191 | optional(seq( 192 | ':', 193 | field('signature', choice($.block, $.module_expression, $.functor)), 194 | )), 195 | optional(seq( 196 | '=', 197 | field('definition', $._module_definition), 198 | )), 199 | )), 200 | 201 | module_declaration: $ => seq( 202 | 'module', 203 | optional('rec'), 204 | optional('type'), 205 | sep1('and', $.module_binding) 206 | ), 207 | 208 | _module_definition: $ => choice( 209 | $.block, 210 | $.module_expression, 211 | $.functor, 212 | $.extension_expression, 213 | ), 214 | 215 | module_unpack: $ => seq( 216 | 'unpack', 217 | '(', 218 | choice( 219 | seq( 220 | choice($.value_identifier, $.value_identifier_path, $.member_expression), 221 | optional($.module_type_annotation) 222 | ), 223 | $.call_expression, 224 | $.extension_expression 225 | ), 226 | ')' 227 | ), 228 | 229 | functor: $ => seq( 230 | field('parameters', $.functor_parameters), 231 | optional(field('return_module_type', $.module_type_annotation)), 232 | '=>', 233 | field('body', $._module_definition), 234 | ), 235 | 236 | functor_parameters: $ => seq( 237 | '(', 238 | optional(commaSep1t($.functor_parameter)), 239 | ')', 240 | ), 241 | 242 | functor_parameter: $ => seq( 243 | $.module_identifier, 244 | $.module_type_annotation, 245 | ), 246 | 247 | module_type_annotation: $ => seq( 248 | ':', 249 | choice( 250 | $.module_expression, 251 | $.block, 252 | ) 253 | ), 254 | 255 | external_declaration: $ => seq( 256 | 'external', 257 | $.value_identifier, 258 | $.type_annotation, 259 | '=', 260 | $.string, 261 | ), 262 | 263 | exception_declaration: $ => seq( 264 | 'exception', 265 | $.variant_identifier, 266 | optional($.variant_parameters), 267 | optional(seq('=', choice($.variant_identifier, $.nested_variant_identifier))) 268 | ), 269 | 270 | type_declaration: $ => seq( 271 | optional('export'), 272 | 'type', 273 | optional('rec'), 274 | sep1( 275 | seq(repeat($._newline), repeat($.decorator), 'and'), 276 | $.type_binding 277 | ) 278 | ), 279 | 280 | type_binding: $ => seq( 281 | field('name', choice($.type_identifier, $.type_identifier_path)), 282 | optional($.type_parameters), 283 | optional(seq( 284 | optional(seq('=', $._non_function_inline_type)), 285 | optional(seq( 286 | choice('=', '+='), 287 | optional('private'), 288 | field('body', $._type), 289 | )), 290 | repeat($.type_constraint), 291 | )), 292 | ), 293 | 294 | type_parameters: $ => seq( 295 | '<', 296 | commaSep1t( 297 | seq( 298 | optional(choice('+', '-')), 299 | $.type_identifier 300 | ) 301 | ), 302 | '>', 303 | ), 304 | 305 | type_annotation: $ => seq( 306 | ':', 307 | repeat($.decorator), 308 | $._inline_type, 309 | ), 310 | 311 | _type: $ => choice( 312 | $._inline_type, 313 | $.variant_type, 314 | $.record_type, 315 | ), 316 | 317 | _inline_type: $ => choice( 318 | $._non_function_inline_type, 319 | $.function_type, 320 | ), 321 | 322 | _non_function_inline_type: $ => choice( 323 | $._type_identifier, 324 | $.tuple_type, 325 | $.polyvar_type, 326 | $.object_type, 327 | $.generic_type, 328 | $.unit_type, 329 | $.module_pack, 330 | $.unit, 331 | $.polymorphic_type, 332 | ), 333 | 334 | polymorphic_type: $ => seq( 335 | choice(repeat1($.type_identifier), $.abstract_type), 336 | '.', 337 | $._inline_type 338 | ), 339 | 340 | type_constraint: $ => seq( 341 | 'constraint', 342 | $._type, 343 | '=', 344 | $._type 345 | ), 346 | 347 | tuple_type: $ => prec.dynamic(-1, seq( 348 | '(', 349 | commaSep1t($._type), 350 | ')', 351 | )), 352 | 353 | variant_type: $ => prec.left(seq( 354 | optional('|'), 355 | barSep1($.variant_declaration), 356 | )), 357 | 358 | variant_declaration: $ => prec.right(seq( 359 | repeat($.decorator), 360 | $.variant_identifier, 361 | optional($.variant_parameters), 362 | optional($.type_annotation), 363 | )), 364 | 365 | variant_parameters: $ => seq( 366 | '(', 367 | commaSep1t($._type), 368 | ')', 369 | ), 370 | 371 | polyvar_type: $ => prec.left(seq( 372 | repeat($.decorator), 373 | choice('[', '[>', '[<',), 374 | optional('|'), 375 | barSep1($.polyvar_declaration), 376 | ']', 377 | optional($.as_aliasing_type) 378 | )), 379 | 380 | polyvar_declaration: $ => prec.right( 381 | choice( 382 | seq( 383 | repeat($.decorator), 384 | $.polyvar_identifier, 385 | optional($.polyvar_parameters), 386 | ), 387 | $._inline_type 388 | ) 389 | ), 390 | 391 | polyvar_parameters: $ => seq( 392 | '(', 393 | commaSep1t($._type), 394 | ')', 395 | ), 396 | 397 | record_type: $ => seq( 398 | '{', 399 | commaSept($.record_type_field), 400 | '}', 401 | ), 402 | 403 | record_type_field: $ => seq( 404 | repeat($.decorator), 405 | optional('mutable'), 406 | alias($.value_identifier, $.property_identifier), 407 | optional('?'), 408 | $.type_annotation, 409 | ), 410 | 411 | object_type: $ => prec.left(seq( 412 | '{', 413 | choice( 414 | commaSep1t($._object_type_field), 415 | seq('.', commaSept($._object_type_field)), 416 | seq('..', commaSept($._object_type_field)), 417 | ), 418 | '}', 419 | optional($.as_aliasing_type) 420 | )), 421 | 422 | _object_type_field: $ => alias($.object_type_field, $.field), 423 | 424 | object_type_field: $ => choice( 425 | seq('...', choice($.type_identifier, $.type_identifier_path)), 426 | seq( 427 | repeat($.decorator), 428 | alias($.string, $.property_identifier), 429 | ':', 430 | $._type, 431 | ), 432 | 433 | ), 434 | 435 | generic_type: $ => prec.left(seq( 436 | $._type_identifier, 437 | $.type_arguments, 438 | optional($.as_aliasing_type) 439 | )), 440 | 441 | type_arguments: $ => seq( 442 | '<', 443 | commaSep1t($._type), 444 | '>' 445 | ), 446 | 447 | function_type: $ => prec.left(seq( 448 | $.function_type_parameters, 449 | '=>', 450 | $._type, 451 | )), 452 | 453 | function_type_parameters: $ => choice( 454 | $._non_function_inline_type, 455 | $._function_type_parameter_list, 456 | ), 457 | 458 | _function_type_parameter_list: $ => seq( 459 | '(', 460 | commaSept(alias($.function_type_parameter, $.parameter)), 461 | ')', 462 | ), 463 | 464 | function_type_parameter: $ => seq( 465 | optional($.uncurry), 466 | repeat($.decorator), 467 | choice( 468 | $._type, 469 | seq($.uncurry, $._type), 470 | $.labeled_parameter, 471 | ), 472 | ), 473 | 474 | let_declaration: $ => seq( 475 | choice('export', 'let'), 476 | optional('rec'), 477 | sep1( 478 | seq(repeat($._newline), repeat($.decorator), 'and'), 479 | $.let_binding 480 | ) 481 | ), 482 | 483 | let_binding: $ => seq( 484 | field('pattern', $._pattern), 485 | choice( 486 | seq( 487 | $.type_annotation, 488 | optional( 489 | seq('=', 490 | repeat($.decorator), 491 | field('body', $.expression) 492 | ) 493 | ) 494 | ), 495 | seq( 496 | '=', 497 | repeat($.decorator), 498 | field('body', $.expression), 499 | ) 500 | ) 501 | ), 502 | 503 | expression_statement: $ => $.expression, 504 | 505 | expression: $ => choice( 506 | $.primary_expression, 507 | $._jsx_element, 508 | $.jsx_fragment, 509 | $.unary_expression, 510 | $.binary_expression, 511 | $.coercion_expression, 512 | $.ternary_expression, 513 | $.for_expression, 514 | $.while_expression, 515 | $.mutation_expression, 516 | $.await_expression, 517 | $.block, 518 | $.assert_expression, 519 | ), 520 | 521 | primary_expression: $ => choice( 522 | $.parenthesized_expression, 523 | $.value_identifier_path, 524 | $.value_identifier, 525 | $.number, 526 | $.string, 527 | $.template_string, 528 | $.character, 529 | $.true, 530 | $.false, 531 | $.function, 532 | $.unit, 533 | $.record, 534 | $.object, 535 | $.tuple, 536 | $.array, 537 | $.list, 538 | $.variant, 539 | $.polyvar, 540 | $.if_expression, 541 | $.switch_expression, 542 | $.try_expression, 543 | $.call_expression, 544 | $.pipe_expression, 545 | $.subscript_expression, 546 | $.member_expression, 547 | $.module_pack, 548 | $.extension_expression, 549 | $.lazy_expression, 550 | ), 551 | 552 | parenthesized_expression: $ => seq( 553 | '(', 554 | repeat($.decorator), 555 | $.expression, 556 | optional($.type_annotation), 557 | ')' 558 | ), 559 | 560 | value_identifier_path: $ => seq( 561 | $.module_primary_expression, 562 | '.', 563 | $.value_identifier, 564 | ), 565 | 566 | function: $ => prec.left(seq( 567 | optional('async'), 568 | choice( 569 | field('parameter', $.value_identifier), 570 | $._definition_signature 571 | ), 572 | '=>', 573 | repeat($.decorator), 574 | field('body', $.expression), 575 | )), 576 | 577 | record: $ => seq( 578 | '{', 579 | choice( 580 | $._record_single_field, 581 | $._record_single_pun_field, 582 | commaSep2t($._record_element), 583 | ), 584 | '}', 585 | ), 586 | 587 | _record_element: $ => choice( 588 | $.spread_element, 589 | $.record_field, 590 | alias($._record_pun_field, $.record_field), 591 | ), 592 | 593 | record_field: $ => seq( 594 | $._record_field_name, 595 | ':', 596 | optional('?'), 597 | $.expression, 598 | ), 599 | 600 | _record_pun_field: $ => seq( 601 | optional('?'), 602 | $._record_field_name, 603 | ), 604 | 605 | _record_single_field: $ => seq( 606 | $.record_field, 607 | optional(','), 608 | ), 609 | 610 | _record_single_pun_field: $ => seq( 611 | '?', 612 | $._record_field_name, 613 | optional(','), 614 | ), 615 | 616 | _record_field_name: $ => choice( 617 | alias($.value_identifier, $.property_identifier), 618 | alias($.value_identifier_path, $.property_identifier), 619 | ), 620 | 621 | object: $ => seq( 622 | '{', 623 | choice( 624 | commaSep1t($._object_field), 625 | seq('.', commaSept($._object_field)), 626 | seq('..', commaSept($._object_field)), 627 | ), 628 | '}', 629 | ), 630 | 631 | _object_field: $ => alias($.object_field, $.field), 632 | 633 | object_field: $ => seq( 634 | alias($.string, $.property_identifier), 635 | ':', 636 | $.expression, 637 | ), 638 | 639 | tuple: $ => seq( 640 | '(', 641 | commaSep2t( 642 | seq(repeat($.decorator), $.expression) 643 | ), 644 | ')', 645 | ), 646 | 647 | array: $ => seq( 648 | '[', 649 | commaSept( 650 | seq(repeat($.decorator), $.expression) 651 | ), 652 | ']' 653 | ), 654 | 655 | list: $ => seq( 656 | $._list_constructor, 657 | '{', 658 | optional( 659 | commaSep1t( 660 | seq(repeat($.decorator), $._list_element) 661 | ) 662 | ), 663 | '}' 664 | ), 665 | 666 | _list_element: $ => choice( 667 | $.expression, 668 | $.spread_element, 669 | ), 670 | 671 | if_expression: $ => seq( 672 | 'if', 673 | $.expression, 674 | $.block, 675 | repeat($.else_if_clause), 676 | optional($.else_clause), 677 | ), 678 | 679 | else_if_clause: $ => seq( 680 | 'else', 681 | 'if', 682 | $.expression, 683 | $.block, 684 | ), 685 | 686 | else_clause: $ => seq( 687 | 'else', 688 | $.block, 689 | ), 690 | 691 | switch_expression: $ => seq( 692 | 'switch', 693 | $.expression, 694 | '{', 695 | repeat($.switch_match), 696 | '}', 697 | ), 698 | 699 | switch_match: $ => prec.dynamic(-1, seq( 700 | '|', 701 | field('pattern', $._pattern), 702 | optional($.guard), 703 | '=>', 704 | field('body', alias($._one_or_more_statements, $.sequence_expression)), 705 | )), 706 | 707 | guard: $ => seq( 708 | choice('if', 'when'), 709 | $.expression, 710 | ), 711 | 712 | polyvar_type_pattern: $ => seq( 713 | '#', 714 | '...', 715 | $._type_identifier, 716 | ), 717 | 718 | try_expression: $ => seq( 719 | 'try', 720 | choice( 721 | $.block, 722 | $.primary_expression, 723 | ), 724 | 'catch', 725 | '{', 726 | repeat($.switch_match), 727 | '}', 728 | ), 729 | 730 | as_aliasing: $ => prec.left(seq( 731 | 'as', 732 | $._pattern, 733 | optional($.type_annotation) 734 | )), 735 | 736 | as_aliasing_type: $ => seq('as', $.type_identifier), 737 | 738 | assert_expression: $ => prec.left(seq('assert', $.expression)), 739 | 740 | call_expression: $ => prec('call', seq( 741 | field('function', $.primary_expression), 742 | field('arguments', alias($.call_arguments, $.arguments)), 743 | )), 744 | 745 | pipe_expression: $ => prec.left(seq( 746 | choice( 747 | $.primary_expression, 748 | $.block, 749 | ), 750 | choice('->', '|>'), 751 | choice( 752 | $.primary_expression, 753 | $.block, 754 | ), 755 | )), 756 | 757 | module_pack: $ => seq( 758 | 'module', 759 | '(', 760 | choice( 761 | $.type_identifier_path, 762 | $._module_definition, 763 | ), 764 | optional($.module_type_annotation), 765 | ')' 766 | ), 767 | 768 | call_arguments: $ => seq( 769 | '(', 770 | optional($.uncurry), 771 | optional(commaSep1t($._call_argument)), 772 | ')' 773 | ), 774 | 775 | _call_argument: $ => choice( 776 | seq( 777 | repeat($.decorator), 778 | $.expression, 779 | optional($.type_annotation), 780 | ), 781 | $.labeled_argument, 782 | ), 783 | 784 | labeled_argument: $ => seq( 785 | '~', 786 | field('label', $.value_identifier), 787 | optional(choice( 788 | '?', 789 | seq( 790 | '=', 791 | optional('?'), 792 | repeat($.decorator), 793 | field('value', $.expression), 794 | optional(field('type', $.type_annotation)), 795 | ), 796 | )), 797 | ), 798 | 799 | _definition_signature: $ => seq( 800 | field('parameters', $.formal_parameters), 801 | optional(field('return_type', alias($._return_type_annotation, $.type_annotation))), 802 | ), 803 | 804 | _return_type_annotation: $ => seq( 805 | ':', 806 | $._non_function_inline_type, 807 | ), 808 | 809 | formal_parameters: $ => seq( 810 | '(', 811 | optional(commaSep1t($.parameter)), 812 | ')' 813 | ), 814 | 815 | parameter: $ => seq( 816 | optional($.uncurry), 817 | choice( 818 | seq($._pattern, optional($.type_annotation)), 819 | $.labeled_parameter, 820 | $.unit, 821 | $.abstract_type 822 | ), 823 | ), 824 | 825 | labeled_parameter: $ => seq( 826 | '~', 827 | $.value_identifier, 828 | optional($.as_aliasing), 829 | optional($.type_annotation), 830 | optional(field('default_value', $._labeled_parameter_default_value)), 831 | ), 832 | 833 | abstract_type: $ => seq( 834 | 'type', 835 | repeat1($.type_identifier), 836 | ), 837 | 838 | _labeled_parameter_default_value: $ => seq( 839 | '=', 840 | choice( 841 | '?', 842 | $.expression, 843 | ), 844 | ), 845 | 846 | // This negative dynamic precedence ensures that during error recovery, 847 | // unfinished constructs are generally treated as literal expressions, 848 | // not patterns. 849 | _pattern: $ => prec.dynamic(-1, seq( 850 | choice( 851 | $.value_identifier, 852 | $._literal_pattern, 853 | $._destructuring_pattern, 854 | $.polyvar_type_pattern, 855 | $.unit, 856 | $.module_pack, 857 | $.lazy_pattern, 858 | $.parenthesized_pattern, 859 | $.or_pattern, 860 | $.range_pattern, 861 | $.exception_pattern 862 | ), 863 | optional($.as_aliasing), 864 | )), 865 | 866 | parenthesized_pattern: $ => seq('(', $._pattern, ')'), 867 | 868 | range_pattern: $ => seq( 869 | $._literal_pattern, 870 | '..', 871 | $._literal_pattern, 872 | ), 873 | 874 | or_pattern: $ => prec.left(seq($._pattern, '|', $._pattern)), 875 | 876 | exception_pattern: $ => seq('exception', $._pattern), 877 | 878 | _destructuring_pattern: $ => choice( 879 | $.variant_pattern, 880 | $.polyvar_pattern, 881 | $.record_pattern, 882 | $.tuple_pattern, 883 | $.array_pattern, 884 | $.list_pattern, 885 | ), 886 | 887 | _literal_pattern: $ => choice( 888 | $.string, 889 | $.template_string, 890 | $.character, 891 | $.number, 892 | $.true, 893 | $.false, 894 | ), 895 | 896 | variant_pattern: $ => seq( 897 | choice( 898 | $.variant_identifier, 899 | $.nested_variant_identifier, 900 | ), 901 | optional(alias($._variant_pattern_parameters, $.formal_parameters)) 902 | ), 903 | 904 | _variant_pattern_parameters: $ => seq( 905 | '(', 906 | commaSept($._variant_pattern_parameter), 907 | ')', 908 | ), 909 | 910 | _variant_pattern_parameter: $ => seq( 911 | $._pattern, 912 | optional($.type_annotation), 913 | ), 914 | 915 | polyvar_pattern: $ => seq( 916 | $.polyvar_identifier, 917 | optional(alias($._variant_pattern_parameters, $.formal_parameters)) 918 | ), 919 | 920 | record_pattern: $ => seq( 921 | '{', 922 | commaSep1t(seq( 923 | choice( 924 | $.value_identifier, 925 | $.value_identifier_path, 926 | ), 927 | optional(seq( 928 | ':', 929 | $._pattern, 930 | )), 931 | )), 932 | '}' 933 | ), 934 | 935 | tuple_item_pattern: $ => seq( 936 | repeat($.decorator), 937 | $._pattern, 938 | optional($.type_annotation), 939 | ), 940 | 941 | tuple_pattern: $ => seq( 942 | '(', 943 | commaSep2t($.tuple_item_pattern), 944 | ')', 945 | ), 946 | 947 | array_pattern: $ => seq( 948 | '[', 949 | optional(commaSep1t( 950 | seq(repeat($.decorator), $._collection_element_pattern) 951 | )), 952 | ']', 953 | ), 954 | 955 | list_pattern: $ => seq( 956 | $._list_constructor, 957 | '{', 958 | optional(commaSep1t( 959 | seq(repeat($.decorator), $._collection_element_pattern) 960 | )), 961 | '}', 962 | ), 963 | 964 | _collection_element_pattern: $ => seq( 965 | choice($._pattern, $.spread_pattern), 966 | optional($.as_aliasing) 967 | ), 968 | 969 | spread_pattern: $ => seq( 970 | '...', 971 | choice($.value_identifier, $.list_pattern, $.array_pattern), 972 | ), 973 | 974 | lazy_pattern: $ => seq( 975 | 'lazy', 976 | choice( 977 | $.value_identifier, 978 | $._literal_pattern, 979 | $._destructuring_pattern, 980 | $.polyvar_type_pattern, 981 | $.parenthesized_pattern, 982 | ) 983 | ), 984 | 985 | _jsx_element: $ => choice($.jsx_element, $.jsx_self_closing_element), 986 | 987 | jsx_element: $ => seq( 988 | field('open_tag', $.jsx_opening_element), 989 | repeat($._jsx_child), 990 | field('close_tag', $.jsx_closing_element) 991 | ), 992 | 993 | jsx_fragment: $ => seq('<', '>', repeat($._jsx_child), '<', '/', '>'), 994 | 995 | jsx_expression: $ => seq( 996 | '{', 997 | optional(choice( 998 | $._one_or_more_statements, 999 | $.spread_element 1000 | )), 1001 | '}' 1002 | ), 1003 | 1004 | _jsx_child: $ => choice( 1005 | $.value_identifier, 1006 | $.value_identifier_path, 1007 | $.number, 1008 | $.string, 1009 | $.template_string, 1010 | $.character, 1011 | $._jsx_element, 1012 | $.jsx_fragment, 1013 | $.block, 1014 | $.spread_element, 1015 | $.member_expression 1016 | ), 1017 | 1018 | jsx_opening_element: $ => prec.dynamic(-1, seq( 1019 | '<', 1020 | field('name', $._jsx_element_name), 1021 | repeat(field('attribute', $._jsx_attribute)), 1022 | '>' 1023 | )), 1024 | 1025 | _jsx_identifier: $ => alias( 1026 | choice($.value_identifier, $.module_identifier), 1027 | $.jsx_identifier 1028 | ), 1029 | 1030 | nested_jsx_identifier: $ => prec('member', seq( 1031 | choice($._jsx_identifier, $.nested_jsx_identifier), 1032 | '.', 1033 | $._jsx_identifier 1034 | )), 1035 | 1036 | _jsx_element_name: $ => choice( 1037 | $._jsx_identifier, 1038 | $.nested_jsx_identifier, 1039 | ), 1040 | 1041 | jsx_closing_element: $ => seq( 1042 | '<', 1043 | '/', 1044 | field('name', $._jsx_element_name), 1045 | '>' 1046 | ), 1047 | 1048 | jsx_self_closing_element: $ => seq( 1049 | '<', 1050 | field('name', $._jsx_element_name), 1051 | repeat(field('attribute', $._jsx_attribute)), 1052 | '/', 1053 | '>' 1054 | ), 1055 | 1056 | _jsx_attribute_name: $ => alias($.value_identifier, $.property_identifier), 1057 | 1058 | _jsx_attribute: $ => choice($.jsx_attribute, $.jsx_expression), 1059 | 1060 | jsx_attribute: $ => seq( 1061 | optional('?'), 1062 | $._jsx_attribute_name, 1063 | optional(seq( 1064 | '=', 1065 | optional('?'), 1066 | $._jsx_attribute_value 1067 | )), 1068 | ), 1069 | 1070 | _jsx_attribute_value: $ => choice( 1071 | $.primary_expression, 1072 | $.jsx_expression, 1073 | ), 1074 | 1075 | mutation_expression: $ => seq( 1076 | $._mutation_lvalue, 1077 | choice('=', ':='), 1078 | $.expression, 1079 | ), 1080 | 1081 | _mutation_lvalue: $ => choice( 1082 | $.value_identifier, 1083 | $.member_expression, 1084 | $.subscript_expression, 1085 | ), 1086 | 1087 | await_expression: $ => seq( 1088 | 'await', 1089 | $.expression, 1090 | ), 1091 | 1092 | decorator: $ => seq( 1093 | '@', 1094 | $.decorator_identifier, 1095 | optional($.decorator_arguments) 1096 | ), 1097 | 1098 | decorator_arguments: $ => seq( 1099 | '(', 1100 | choice( 1101 | commaSept($.expression), 1102 | $.type_annotation 1103 | ), 1104 | ')', 1105 | ), 1106 | 1107 | subscript_expression: $ => prec.right('member', seq( 1108 | field('object', $.primary_expression), 1109 | '[', field('index', $.expression), ']' 1110 | )), 1111 | 1112 | member_expression: $ => prec('member', seq( 1113 | field('record', $.primary_expression), 1114 | '.', 1115 | optional(seq( 1116 | field('module', $.module_identifier), 1117 | '.' 1118 | )), 1119 | field('property', alias($.value_identifier, $.property_identifier)), 1120 | )), 1121 | 1122 | spread_element: $ => seq('...', $.expression), 1123 | 1124 | ternary_expression: $ => prec.left(seq( 1125 | field('condition', $.expression), 1126 | '?', 1127 | field('consequence', $.expression), 1128 | ':', 1129 | field('alternative', $.expression) 1130 | )), 1131 | 1132 | for_expression: $ => seq( 1133 | 'for', 1134 | $.value_identifier, 1135 | 'in', 1136 | $.expression, 1137 | choice('to', 'downto'), 1138 | $.expression, 1139 | $.block, 1140 | ), 1141 | 1142 | while_expression: $ => seq( 1143 | 'while', 1144 | $.expression, 1145 | $.block, 1146 | ), 1147 | 1148 | lazy_expression: $ => seq( 1149 | 'lazy', 1150 | $.expression, 1151 | ), 1152 | 1153 | binary_expression: $ => choice( 1154 | ...[ 1155 | ['&&', 'binary_and'], 1156 | ['||', 'binary_or'], 1157 | ['++', 'binary_plus'], 1158 | ['+', 'binary_plus'], 1159 | ['+.', 'binary_plus'], 1160 | ['-', 'binary_plus'], 1161 | ['-.', 'binary_plus'], 1162 | ['*', 'binary_times'], 1163 | ['*.', 'binary_times'], 1164 | ['**', 'binary_pow'], 1165 | ['/', 'binary_times'], 1166 | ['/.', 'binary_times'], 1167 | ['<', 'binary_relation'], 1168 | ['<=', 'binary_relation'], 1169 | ['==', 'binary_relation'], 1170 | ['===', 'binary_relation'], 1171 | ['!=', 'binary_relation'], 1172 | ['!==', 'binary_relation'], 1173 | ['>=', 'binary_relation'], 1174 | ['>', 'binary_relation'], 1175 | ].map(([operator, precedence]) => 1176 | prec.left(precedence, seq( 1177 | field('left', $.expression), 1178 | field('operator', operator), 1179 | field('right', $.expression) 1180 | )) 1181 | ) 1182 | ), 1183 | 1184 | coercion_expression: $ => prec.left( 1185 | 'coercion_relation', 1186 | seq( 1187 | field('left', $.expression), 1188 | field('operator', ':>'), 1189 | field('right', $._type_identifier), 1190 | ) 1191 | ), 1192 | 1193 | unary_expression: $ => choice(...[ 1194 | ['!', 'unary_not'], 1195 | ['-', 'unary_not'], 1196 | ['-.', 'unary_not'], 1197 | ['+', 'unary_not'], 1198 | ['+.', 'unary_not'], 1199 | ].map(([operator, precedence]) => 1200 | prec.left(precedence, seq( 1201 | field('operator', operator), 1202 | field('argument', $.expression) 1203 | )) 1204 | )), 1205 | 1206 | extension_expression: $ => prec.right(seq( 1207 | repeat1('%'), 1208 | $.extension_identifier, 1209 | optional( 1210 | $._extension_expression_payload, 1211 | ) 1212 | )), 1213 | 1214 | _extension_expression_payload: $ => seq( 1215 | '(', 1216 | $._one_or_more_statements, 1217 | // explicit newline here because it won’t be reported otherwise by the scanner 1218 | // because we’re in parens 1219 | optional($._newline), 1220 | ')', 1221 | ), 1222 | 1223 | variant: $ => prec.right(seq( 1224 | choice($.variant_identifier, $.nested_variant_identifier), 1225 | optional(alias($.variant_arguments, $.arguments)), 1226 | )), 1227 | 1228 | nested_variant_identifier: $ => seq( 1229 | $.module_primary_expression, 1230 | '.', 1231 | $.variant_identifier 1232 | ), 1233 | 1234 | variant_arguments: $ => seq( 1235 | '(', 1236 | commaSept(seq( 1237 | $.expression, 1238 | optional($.type_annotation), 1239 | )), 1240 | ')', 1241 | ), 1242 | 1243 | polyvar: $ => prec.right(seq( 1244 | $.polyvar_identifier, 1245 | optional(alias($.variant_arguments, $.arguments)), 1246 | )), 1247 | 1248 | _type_identifier: $ => choice( 1249 | $.type_identifier, 1250 | $.type_identifier_path, 1251 | ".." 1252 | ), 1253 | 1254 | type_identifier_path: $ => seq( 1255 | $.module_primary_expression, 1256 | '.', 1257 | $.type_identifier 1258 | ), 1259 | 1260 | module_expression: $ => choice( 1261 | $.module_primary_expression, 1262 | $.module_type_of, 1263 | $.module_type_constraint, 1264 | ), 1265 | 1266 | module_primary_expression: $ => choice( 1267 | $.parenthesized_module_expression, 1268 | $.module_identifier, 1269 | $.module_identifier_path, 1270 | $.functor_use, 1271 | $.module_unpack, 1272 | ), 1273 | 1274 | parenthesized_module_expression: $ => seq( 1275 | '(', 1276 | $.module_expression, 1277 | optional($.module_type_annotation), 1278 | ')', 1279 | ), 1280 | 1281 | module_identifier_path: $ => path( 1282 | $.module_primary_expression, 1283 | $.module_identifier, 1284 | ), 1285 | 1286 | module_type_of: $ => prec.left(seq( 1287 | 'module', 1288 | 'type', 1289 | 'of', 1290 | choice($.module_expression, $.block) 1291 | )), 1292 | 1293 | _module_type_constraint_with: $ => prec.right(seq( 1294 | 'with', 1295 | sep1(choice('and', 'with'), 1296 | choice($.constrain_module, $.constrain_type) 1297 | ), 1298 | )), 1299 | 1300 | module_type_constraint: $ => prec.left(choice( 1301 | seq($.module_expression, $._module_type_constraint_with), 1302 | seq( 1303 | '(', 1304 | $.module_expression, $._module_type_constraint_with, 1305 | ')', 1306 | $._module_type_constraint_with 1307 | ) 1308 | )), 1309 | 1310 | constrain_module: $ => seq( 1311 | 'module', 1312 | $.module_primary_expression, 1313 | choice('=', ':='), 1314 | $.module_primary_expression, 1315 | ), 1316 | 1317 | constrain_type: $ => seq( 1318 | 'type', 1319 | $._type, 1320 | choice('=', ':='), 1321 | $._type, 1322 | ), 1323 | 1324 | functor_use: $ => seq( 1325 | $.module_primary_expression, 1326 | alias($.functor_arguments, $.arguments), 1327 | ), 1328 | 1329 | functor_arguments: $ => seq( 1330 | '(', 1331 | optional(commaSep1t($._functor_argument)), 1332 | ')', 1333 | ), 1334 | 1335 | _functor_argument: $ => choice( 1336 | $.module_expression, 1337 | $.block, 1338 | ), 1339 | 1340 | variant_identifier: $ => /[A-Z][a-zA-Z0-9_']*/, 1341 | 1342 | polyvar_identifier: $ => seq( 1343 | '#', 1344 | choice( 1345 | /[a-zA-Z0-9_']+/, 1346 | seq( 1347 | optional('\\'), 1348 | alias($.string, $.polyvar_string), 1349 | ), 1350 | ), 1351 | ), 1352 | 1353 | type_identifier: $ => choice( 1354 | /[a-z_'][a-zA-Z0-9_']*/, 1355 | $._escape_identifier, 1356 | ), 1357 | 1358 | value_identifier: $ => choice( 1359 | /[a-z_][a-zA-Z0-9_']*/, 1360 | $._reserved_identifier, 1361 | $._escape_identifier, 1362 | ), 1363 | 1364 | _escape_identifier: $ => token(seq('\\"', /[^"]+/, '"')), 1365 | 1366 | module_identifier: $ => /[A-Z][a-zA-Z0-9_']*/, 1367 | 1368 | decorator_identifier: $ => /[a-zA-Z0-9_\.]+/, 1369 | 1370 | extension_identifier: $ => /[a-zA-Z0-9_\.]+/, 1371 | 1372 | number: $ => { 1373 | const hex_literal = seq( 1374 | choice('0x', '0X'), 1375 | /[\da-fA-F](_?[\da-fA-F])*/ 1376 | ) 1377 | 1378 | const decimal_digits = /\d(_?\d)*/ 1379 | const signed_integer = seq(optional(choice('-', '+')), decimal_digits) 1380 | const exponent_part = seq(choice('e', 'E'), signed_integer) 1381 | 1382 | const binary_literal = seq(choice('0b', '0B'), /[0-1](_?[0-1])*/) 1383 | 1384 | const octal_literal = seq(choice('0o', '0O'), /[0-7](_?[0-7])*/) 1385 | 1386 | const bigint_literal = seq(choice(hex_literal, binary_literal, octal_literal, decimal_digits), 'n') 1387 | 1388 | const decimal_integer_literal = choice( 1389 | '0', 1390 | seq(optional('0'), /[1-9]/, optional(seq(optional('_'), decimal_digits))) 1391 | ) 1392 | 1393 | const decimal_literal = seq( 1394 | optional(choice('-', '+')), 1395 | choice( 1396 | seq(decimal_integer_literal, '.', optional(decimal_digits), optional(exponent_part)), 1397 | seq('.', decimal_digits, optional(exponent_part)), 1398 | seq(decimal_integer_literal, exponent_part), 1399 | seq(decimal_digits), 1400 | ) 1401 | ) 1402 | 1403 | const int_32_64 = seq( 1404 | optional(choice('-', '+')), 1405 | choice(decimal_integer_literal, binary_literal, octal_literal, hex_literal), 1406 | choice('L', 'l') 1407 | ) 1408 | 1409 | return token(choice( 1410 | hex_literal, 1411 | decimal_literal, 1412 | binary_literal, 1413 | octal_literal, 1414 | bigint_literal, 1415 | int_32_64 1416 | )) 1417 | }, 1418 | 1419 | unit: $ => seq('(', ')'), 1420 | unit_type: $ => 'unit', 1421 | 1422 | true: $ => 'true', 1423 | false: $ => 'false', 1424 | 1425 | string: $ => seq( 1426 | '"', 1427 | repeat(choice( 1428 | alias($.unescaped_double_string_fragment, $.string_fragment), 1429 | $.escape_sequence 1430 | )), 1431 | '"' 1432 | ), 1433 | 1434 | // Workaround to https://github.com/tree-sitter/tree-sitter/issues/1156 1435 | // We give names to the token() constructs containing a regexp 1436 | // so as to obtain a node in the CST. 1437 | // 1438 | unescaped_double_string_fragment: $ => 1439 | token.immediate(prec(1, /[^"\\]+/)), 1440 | 1441 | escape_sequence: $ => token.immediate(seq( 1442 | '\\', 1443 | choice( 1444 | /[^xu0-7]/, 1445 | /[0-7]{1,3}/, 1446 | /x[0-9a-fA-F]{2}/, 1447 | /u[0-9a-fA-F]{4}/, 1448 | /u{[0-9a-fA-F]+}/ 1449 | ) 1450 | )), 1451 | 1452 | template_string: $ => seq( 1453 | token(seq( 1454 | optional( 1455 | choice( 1456 | /[a-z_][a-zA-Z0-9_']*/, 1457 | // escape_sequence 1458 | seq('\\"', /[^"]+/, '"'), 1459 | ) 1460 | ), 1461 | '`', 1462 | )), 1463 | $.template_string_content, 1464 | '`' 1465 | ), 1466 | 1467 | template_string_content: $ => 1468 | repeat1( 1469 | choice( 1470 | $._template_chars, 1471 | $.template_substitution, 1472 | choice( 1473 | alias('\\`', $.escape_sequence), 1474 | $.escape_sequence, 1475 | ) 1476 | ), 1477 | ), 1478 | 1479 | template_substitution: $ => choice( 1480 | seq('$', $.value_identifier), 1481 | seq('${', $.expression, '}'), 1482 | ), 1483 | 1484 | character: $ => seq( 1485 | "'", 1486 | repeat(choice(/[^\\']/, $.escape_sequence)), 1487 | "'" 1488 | ), 1489 | 1490 | _unescaped_template_string_fragment: $ => 1491 | token.immediate(prec(1, /[^`\\\$]+/)), 1492 | 1493 | lparen: $ => alias($._lparen, '('), 1494 | rparen: $ => alias($._rparen, ')'), 1495 | uncurry: $ => '.', 1496 | 1497 | _reserved_identifier: $ => choice( 1498 | 'async' 1499 | ) 1500 | }, 1501 | }); 1502 | 1503 | function barSep1(rule) { 1504 | return seq(rule, repeat(seq('|', rule))); 1505 | } 1506 | 1507 | function commaSep1(rule) { 1508 | return seq(rule, repeat(seq(',', rule))); 1509 | } 1510 | 1511 | function commaSep2(rule) { 1512 | return seq(rule, ',', commaSep1(rule)); 1513 | } 1514 | 1515 | function commaSep1t(rule) { 1516 | return seq(commaSep1(rule), optional(',')); 1517 | } 1518 | 1519 | function commaSep2t(rule) { 1520 | return seq(commaSep2(rule), optional(',')); 1521 | } 1522 | 1523 | function commaSep(rule) { 1524 | return optional(commaSep1(rule)); 1525 | } 1526 | 1527 | function commaSept(rule) { 1528 | return optional(commaSep1t(rule)); 1529 | } 1530 | 1531 | function sep1(delimiter, rule) { 1532 | return seq(rule, repeat(seq(delimiter, rule))) 1533 | } 1534 | 1535 | function path(prefix, final) { 1536 | return choice(final, seq(prefix, '.', final)) 1537 | } 1538 | -------------------------------------------------------------------------------- /tree-sitter-rescript/src/node-types.json: -------------------------------------------------------------------------------- 1 | [ 2 | { 3 | "type": "_type", 4 | "named": true, 5 | "subtypes": [ 6 | { 7 | "type": "..", 8 | "named": false 9 | }, 10 | { 11 | "type": "function_type", 12 | "named": true 13 | }, 14 | { 15 | "type": "generic_type", 16 | "named": true 17 | }, 18 | { 19 | "type": "module_pack", 20 | "named": true 21 | }, 22 | { 23 | "type": "object_type", 24 | "named": true 25 | }, 26 | { 27 | "type": "polymorphic_type", 28 | "named": true 29 | }, 30 | { 31 | "type": "polyvar_type", 32 | "named": true 33 | }, 34 | { 35 | "type": "record_type", 36 | "named": true 37 | }, 38 | { 39 | "type": "tuple_type", 40 | "named": true 41 | }, 42 | { 43 | "type": "type_identifier", 44 | "named": true 45 | }, 46 | { 47 | "type": "type_identifier_path", 48 | "named": true 49 | }, 50 | { 51 | "type": "unit", 52 | "named": true 53 | }, 54 | { 55 | "type": "unit_type", 56 | "named": true 57 | }, 58 | { 59 | "type": "variant_type", 60 | "named": true 61 | } 62 | ] 63 | }, 64 | { 65 | "type": "declaration", 66 | "named": true, 67 | "subtypes": [ 68 | { 69 | "type": "exception_declaration", 70 | "named": true 71 | }, 72 | { 73 | "type": "external_declaration", 74 | "named": true 75 | }, 76 | { 77 | "type": "let_declaration", 78 | "named": true 79 | }, 80 | { 81 | "type": "module_declaration", 82 | "named": true 83 | }, 84 | { 85 | "type": "type_declaration", 86 | "named": true 87 | } 88 | ] 89 | }, 90 | { 91 | "type": "expression", 92 | "named": true, 93 | "subtypes": [ 94 | { 95 | "type": "assert_expression", 96 | "named": true 97 | }, 98 | { 99 | "type": "await_expression", 100 | "named": true 101 | }, 102 | { 103 | "type": "binary_expression", 104 | "named": true 105 | }, 106 | { 107 | "type": "block", 108 | "named": true 109 | }, 110 | { 111 | "type": "coercion_expression", 112 | "named": true 113 | }, 114 | { 115 | "type": "for_expression", 116 | "named": true 117 | }, 118 | { 119 | "type": "jsx_element", 120 | "named": true 121 | }, 122 | { 123 | "type": "jsx_fragment", 124 | "named": true 125 | }, 126 | { 127 | "type": "jsx_self_closing_element", 128 | "named": true 129 | }, 130 | { 131 | "type": "mutation_expression", 132 | "named": true 133 | }, 134 | { 135 | "type": "primary_expression", 136 | "named": true 137 | }, 138 | { 139 | "type": "ternary_expression", 140 | "named": true 141 | }, 142 | { 143 | "type": "unary_expression", 144 | "named": true 145 | }, 146 | { 147 | "type": "while_expression", 148 | "named": true 149 | } 150 | ] 151 | }, 152 | { 153 | "type": "module_expression", 154 | "named": true, 155 | "subtypes": [ 156 | { 157 | "type": "module_primary_expression", 158 | "named": true 159 | }, 160 | { 161 | "type": "module_type_constraint", 162 | "named": true 163 | }, 164 | { 165 | "type": "module_type_of", 166 | "named": true 167 | } 168 | ] 169 | }, 170 | { 171 | "type": "module_primary_expression", 172 | "named": true, 173 | "subtypes": [ 174 | { 175 | "type": "functor_use", 176 | "named": true 177 | }, 178 | { 179 | "type": "module_identifier", 180 | "named": true 181 | }, 182 | { 183 | "type": "module_identifier_path", 184 | "named": true 185 | }, 186 | { 187 | "type": "module_unpack", 188 | "named": true 189 | }, 190 | { 191 | "type": "parenthesized_module_expression", 192 | "named": true 193 | } 194 | ] 195 | }, 196 | { 197 | "type": "primary_expression", 198 | "named": true, 199 | "subtypes": [ 200 | { 201 | "type": "array", 202 | "named": true 203 | }, 204 | { 205 | "type": "call_expression", 206 | "named": true 207 | }, 208 | { 209 | "type": "character", 210 | "named": true 211 | }, 212 | { 213 | "type": "extension_expression", 214 | "named": true 215 | }, 216 | { 217 | "type": "false", 218 | "named": true 219 | }, 220 | { 221 | "type": "function", 222 | "named": true 223 | }, 224 | { 225 | "type": "if_expression", 226 | "named": true 227 | }, 228 | { 229 | "type": "lazy_expression", 230 | "named": true 231 | }, 232 | { 233 | "type": "list", 234 | "named": true 235 | }, 236 | { 237 | "type": "member_expression", 238 | "named": true 239 | }, 240 | { 241 | "type": "module_pack", 242 | "named": true 243 | }, 244 | { 245 | "type": "number", 246 | "named": true 247 | }, 248 | { 249 | "type": "object", 250 | "named": true 251 | }, 252 | { 253 | "type": "parenthesized_expression", 254 | "named": true 255 | }, 256 | { 257 | "type": "pipe_expression", 258 | "named": true 259 | }, 260 | { 261 | "type": "polyvar", 262 | "named": true 263 | }, 264 | { 265 | "type": "record", 266 | "named": true 267 | }, 268 | { 269 | "type": "string", 270 | "named": true 271 | }, 272 | { 273 | "type": "subscript_expression", 274 | "named": true 275 | }, 276 | { 277 | "type": "switch_expression", 278 | "named": true 279 | }, 280 | { 281 | "type": "template_string", 282 | "named": true 283 | }, 284 | { 285 | "type": "true", 286 | "named": true 287 | }, 288 | { 289 | "type": "try_expression", 290 | "named": true 291 | }, 292 | { 293 | "type": "tuple", 294 | "named": true 295 | }, 296 | { 297 | "type": "unit", 298 | "named": true 299 | }, 300 | { 301 | "type": "value_identifier", 302 | "named": true 303 | }, 304 | { 305 | "type": "value_identifier_path", 306 | "named": true 307 | }, 308 | { 309 | "type": "variant", 310 | "named": true 311 | } 312 | ] 313 | }, 314 | { 315 | "type": "statement", 316 | "named": true, 317 | "subtypes": [ 318 | { 319 | "type": "declaration", 320 | "named": true 321 | }, 322 | { 323 | "type": "decorated", 324 | "named": true 325 | }, 326 | { 327 | "type": "decorator_statement", 328 | "named": true 329 | }, 330 | { 331 | "type": "expression_statement", 332 | "named": true 333 | }, 334 | { 335 | "type": "include_statement", 336 | "named": true 337 | }, 338 | { 339 | "type": "open_statement", 340 | "named": true 341 | } 342 | ] 343 | }, 344 | { 345 | "type": "abstract_type", 346 | "named": true, 347 | "fields": {}, 348 | "children": { 349 | "multiple": true, 350 | "required": true, 351 | "types": [ 352 | { 353 | "type": "type_identifier", 354 | "named": true 355 | } 356 | ] 357 | } 358 | }, 359 | { 360 | "type": "arguments", 361 | "named": true, 362 | "fields": {}, 363 | "children": { 364 | "multiple": true, 365 | "required": false, 366 | "types": [ 367 | { 368 | "type": "decorator", 369 | "named": true 370 | }, 371 | { 372 | "type": "expression", 373 | "named": true 374 | }, 375 | { 376 | "type": "labeled_argument", 377 | "named": true 378 | }, 379 | { 380 | "type": "module_expression", 381 | "named": true 382 | }, 383 | { 384 | "type": "type_annotation", 385 | "named": true 386 | }, 387 | { 388 | "type": "uncurry", 389 | "named": true 390 | } 391 | ] 392 | } 393 | }, 394 | { 395 | "type": "array", 396 | "named": true, 397 | "fields": {}, 398 | "children": { 399 | "multiple": true, 400 | "required": false, 401 | "types": [ 402 | { 403 | "type": "decorator", 404 | "named": true 405 | }, 406 | { 407 | "type": "expression", 408 | "named": true 409 | } 410 | ] 411 | } 412 | }, 413 | { 414 | "type": "array_pattern", 415 | "named": true, 416 | "fields": {}, 417 | "children": { 418 | "multiple": true, 419 | "required": false, 420 | "types": [ 421 | { 422 | "type": "array_pattern", 423 | "named": true 424 | }, 425 | { 426 | "type": "as_aliasing", 427 | "named": true 428 | }, 429 | { 430 | "type": "character", 431 | "named": true 432 | }, 433 | { 434 | "type": "decorator", 435 | "named": true 436 | }, 437 | { 438 | "type": "exception_pattern", 439 | "named": true 440 | }, 441 | { 442 | "type": "false", 443 | "named": true 444 | }, 445 | { 446 | "type": "lazy_pattern", 447 | "named": true 448 | }, 449 | { 450 | "type": "list_pattern", 451 | "named": true 452 | }, 453 | { 454 | "type": "module_pack", 455 | "named": true 456 | }, 457 | { 458 | "type": "number", 459 | "named": true 460 | }, 461 | { 462 | "type": "or_pattern", 463 | "named": true 464 | }, 465 | { 466 | "type": "parenthesized_pattern", 467 | "named": true 468 | }, 469 | { 470 | "type": "polyvar_pattern", 471 | "named": true 472 | }, 473 | { 474 | "type": "polyvar_type_pattern", 475 | "named": true 476 | }, 477 | { 478 | "type": "range_pattern", 479 | "named": true 480 | }, 481 | { 482 | "type": "record_pattern", 483 | "named": true 484 | }, 485 | { 486 | "type": "spread_pattern", 487 | "named": true 488 | }, 489 | { 490 | "type": "string", 491 | "named": true 492 | }, 493 | { 494 | "type": "template_string", 495 | "named": true 496 | }, 497 | { 498 | "type": "true", 499 | "named": true 500 | }, 501 | { 502 | "type": "tuple_pattern", 503 | "named": true 504 | }, 505 | { 506 | "type": "unit", 507 | "named": true 508 | }, 509 | { 510 | "type": "value_identifier", 511 | "named": true 512 | }, 513 | { 514 | "type": "variant_pattern", 515 | "named": true 516 | } 517 | ] 518 | } 519 | }, 520 | { 521 | "type": "as_aliasing", 522 | "named": true, 523 | "fields": {}, 524 | "children": { 525 | "multiple": true, 526 | "required": true, 527 | "types": [ 528 | { 529 | "type": "array_pattern", 530 | "named": true 531 | }, 532 | { 533 | "type": "as_aliasing", 534 | "named": true 535 | }, 536 | { 537 | "type": "character", 538 | "named": true 539 | }, 540 | { 541 | "type": "exception_pattern", 542 | "named": true 543 | }, 544 | { 545 | "type": "false", 546 | "named": true 547 | }, 548 | { 549 | "type": "lazy_pattern", 550 | "named": true 551 | }, 552 | { 553 | "type": "list_pattern", 554 | "named": true 555 | }, 556 | { 557 | "type": "module_pack", 558 | "named": true 559 | }, 560 | { 561 | "type": "number", 562 | "named": true 563 | }, 564 | { 565 | "type": "or_pattern", 566 | "named": true 567 | }, 568 | { 569 | "type": "parenthesized_pattern", 570 | "named": true 571 | }, 572 | { 573 | "type": "polyvar_pattern", 574 | "named": true 575 | }, 576 | { 577 | "type": "polyvar_type_pattern", 578 | "named": true 579 | }, 580 | { 581 | "type": "range_pattern", 582 | "named": true 583 | }, 584 | { 585 | "type": "record_pattern", 586 | "named": true 587 | }, 588 | { 589 | "type": "string", 590 | "named": true 591 | }, 592 | { 593 | "type": "template_string", 594 | "named": true 595 | }, 596 | { 597 | "type": "true", 598 | "named": true 599 | }, 600 | { 601 | "type": "tuple_pattern", 602 | "named": true 603 | }, 604 | { 605 | "type": "type_annotation", 606 | "named": true 607 | }, 608 | { 609 | "type": "unit", 610 | "named": true 611 | }, 612 | { 613 | "type": "value_identifier", 614 | "named": true 615 | }, 616 | { 617 | "type": "variant_pattern", 618 | "named": true 619 | } 620 | ] 621 | } 622 | }, 623 | { 624 | "type": "as_aliasing_type", 625 | "named": true, 626 | "fields": {}, 627 | "children": { 628 | "multiple": false, 629 | "required": true, 630 | "types": [ 631 | { 632 | "type": "type_identifier", 633 | "named": true 634 | } 635 | ] 636 | } 637 | }, 638 | { 639 | "type": "assert_expression", 640 | "named": true, 641 | "fields": {}, 642 | "children": { 643 | "multiple": false, 644 | "required": true, 645 | "types": [ 646 | { 647 | "type": "expression", 648 | "named": true 649 | } 650 | ] 651 | } 652 | }, 653 | { 654 | "type": "await_expression", 655 | "named": true, 656 | "fields": {}, 657 | "children": { 658 | "multiple": false, 659 | "required": true, 660 | "types": [ 661 | { 662 | "type": "expression", 663 | "named": true 664 | } 665 | ] 666 | } 667 | }, 668 | { 669 | "type": "binary_expression", 670 | "named": true, 671 | "fields": { 672 | "left": { 673 | "multiple": false, 674 | "required": true, 675 | "types": [ 676 | { 677 | "type": "expression", 678 | "named": true 679 | } 680 | ] 681 | }, 682 | "operator": { 683 | "multiple": false, 684 | "required": true, 685 | "types": [ 686 | { 687 | "type": "!=", 688 | "named": false 689 | }, 690 | { 691 | "type": "!==", 692 | "named": false 693 | }, 694 | { 695 | "type": "&&", 696 | "named": false 697 | }, 698 | { 699 | "type": "*", 700 | "named": false 701 | }, 702 | { 703 | "type": "**", 704 | "named": false 705 | }, 706 | { 707 | "type": "*.", 708 | "named": false 709 | }, 710 | { 711 | "type": "+", 712 | "named": false 713 | }, 714 | { 715 | "type": "++", 716 | "named": false 717 | }, 718 | { 719 | "type": "+.", 720 | "named": false 721 | }, 722 | { 723 | "type": "-", 724 | "named": false 725 | }, 726 | { 727 | "type": "-.", 728 | "named": false 729 | }, 730 | { 731 | "type": "/", 732 | "named": false 733 | }, 734 | { 735 | "type": "/.", 736 | "named": false 737 | }, 738 | { 739 | "type": "<", 740 | "named": false 741 | }, 742 | { 743 | "type": "<=", 744 | "named": false 745 | }, 746 | { 747 | "type": "==", 748 | "named": false 749 | }, 750 | { 751 | "type": "===", 752 | "named": false 753 | }, 754 | { 755 | "type": ">", 756 | "named": false 757 | }, 758 | { 759 | "type": ">=", 760 | "named": false 761 | }, 762 | { 763 | "type": "||", 764 | "named": false 765 | } 766 | ] 767 | }, 768 | "right": { 769 | "multiple": false, 770 | "required": true, 771 | "types": [ 772 | { 773 | "type": "expression", 774 | "named": true 775 | } 776 | ] 777 | } 778 | } 779 | }, 780 | { 781 | "type": "block", 782 | "named": true, 783 | "fields": {}, 784 | "children": { 785 | "multiple": true, 786 | "required": false, 787 | "types": [ 788 | { 789 | "type": "comment", 790 | "named": true 791 | }, 792 | { 793 | "type": "statement", 794 | "named": true 795 | } 796 | ] 797 | } 798 | }, 799 | { 800 | "type": "call_expression", 801 | "named": true, 802 | "fields": { 803 | "arguments": { 804 | "multiple": false, 805 | "required": true, 806 | "types": [ 807 | { 808 | "type": "arguments", 809 | "named": true 810 | } 811 | ] 812 | }, 813 | "function": { 814 | "multiple": false, 815 | "required": true, 816 | "types": [ 817 | { 818 | "type": "primary_expression", 819 | "named": true 820 | } 821 | ] 822 | } 823 | } 824 | }, 825 | { 826 | "type": "character", 827 | "named": true, 828 | "fields": {}, 829 | "children": { 830 | "multiple": true, 831 | "required": false, 832 | "types": [ 833 | { 834 | "type": "escape_sequence", 835 | "named": true 836 | } 837 | ] 838 | } 839 | }, 840 | { 841 | "type": "coercion_expression", 842 | "named": true, 843 | "fields": { 844 | "left": { 845 | "multiple": false, 846 | "required": true, 847 | "types": [ 848 | { 849 | "type": "expression", 850 | "named": true 851 | } 852 | ] 853 | }, 854 | "operator": { 855 | "multiple": false, 856 | "required": true, 857 | "types": [ 858 | { 859 | "type": ":>", 860 | "named": false 861 | } 862 | ] 863 | }, 864 | "right": { 865 | "multiple": false, 866 | "required": true, 867 | "types": [ 868 | { 869 | "type": "..", 870 | "named": false 871 | }, 872 | { 873 | "type": "type_identifier", 874 | "named": true 875 | }, 876 | { 877 | "type": "type_identifier_path", 878 | "named": true 879 | } 880 | ] 881 | } 882 | } 883 | }, 884 | { 885 | "type": "constrain_module", 886 | "named": true, 887 | "fields": {}, 888 | "children": { 889 | "multiple": true, 890 | "required": true, 891 | "types": [ 892 | { 893 | "type": "module_primary_expression", 894 | "named": true 895 | } 896 | ] 897 | } 898 | }, 899 | { 900 | "type": "constrain_type", 901 | "named": true, 902 | "fields": {}, 903 | "children": { 904 | "multiple": true, 905 | "required": true, 906 | "types": [ 907 | { 908 | "type": "_type", 909 | "named": true 910 | } 911 | ] 912 | } 913 | }, 914 | { 915 | "type": "decorated", 916 | "named": true, 917 | "fields": {}, 918 | "children": { 919 | "multiple": true, 920 | "required": true, 921 | "types": [ 922 | { 923 | "type": "declaration", 924 | "named": true 925 | }, 926 | { 927 | "type": "decorator", 928 | "named": true 929 | }, 930 | { 931 | "type": "expression_statement", 932 | "named": true 933 | } 934 | ] 935 | } 936 | }, 937 | { 938 | "type": "decorator", 939 | "named": true, 940 | "fields": {}, 941 | "children": { 942 | "multiple": true, 943 | "required": true, 944 | "types": [ 945 | { 946 | "type": "decorator_arguments", 947 | "named": true 948 | }, 949 | { 950 | "type": "decorator_identifier", 951 | "named": true 952 | } 953 | ] 954 | } 955 | }, 956 | { 957 | "type": "decorator_arguments", 958 | "named": true, 959 | "fields": {}, 960 | "children": { 961 | "multiple": true, 962 | "required": false, 963 | "types": [ 964 | { 965 | "type": "expression", 966 | "named": true 967 | }, 968 | { 969 | "type": "type_annotation", 970 | "named": true 971 | } 972 | ] 973 | } 974 | }, 975 | { 976 | "type": "decorator_identifier", 977 | "named": true, 978 | "fields": {} 979 | }, 980 | { 981 | "type": "decorator_statement", 982 | "named": true, 983 | "fields": {}, 984 | "children": { 985 | "multiple": true, 986 | "required": true, 987 | "types": [ 988 | { 989 | "type": "decorator_arguments", 990 | "named": true 991 | }, 992 | { 993 | "type": "decorator_identifier", 994 | "named": true 995 | } 996 | ] 997 | } 998 | }, 999 | { 1000 | "type": "else_clause", 1001 | "named": true, 1002 | "fields": {}, 1003 | "children": { 1004 | "multiple": false, 1005 | "required": true, 1006 | "types": [ 1007 | { 1008 | "type": "block", 1009 | "named": true 1010 | } 1011 | ] 1012 | } 1013 | }, 1014 | { 1015 | "type": "else_if_clause", 1016 | "named": true, 1017 | "fields": {}, 1018 | "children": { 1019 | "multiple": true, 1020 | "required": true, 1021 | "types": [ 1022 | { 1023 | "type": "expression", 1024 | "named": true 1025 | } 1026 | ] 1027 | } 1028 | }, 1029 | { 1030 | "type": "exception_declaration", 1031 | "named": true, 1032 | "fields": {}, 1033 | "children": { 1034 | "multiple": true, 1035 | "required": true, 1036 | "types": [ 1037 | { 1038 | "type": "nested_variant_identifier", 1039 | "named": true 1040 | }, 1041 | { 1042 | "type": "variant_identifier", 1043 | "named": true 1044 | }, 1045 | { 1046 | "type": "variant_parameters", 1047 | "named": true 1048 | } 1049 | ] 1050 | } 1051 | }, 1052 | { 1053 | "type": "exception_pattern", 1054 | "named": true, 1055 | "fields": {}, 1056 | "children": { 1057 | "multiple": true, 1058 | "required": true, 1059 | "types": [ 1060 | { 1061 | "type": "array_pattern", 1062 | "named": true 1063 | }, 1064 | { 1065 | "type": "as_aliasing", 1066 | "named": true 1067 | }, 1068 | { 1069 | "type": "character", 1070 | "named": true 1071 | }, 1072 | { 1073 | "type": "exception_pattern", 1074 | "named": true 1075 | }, 1076 | { 1077 | "type": "false", 1078 | "named": true 1079 | }, 1080 | { 1081 | "type": "lazy_pattern", 1082 | "named": true 1083 | }, 1084 | { 1085 | "type": "list_pattern", 1086 | "named": true 1087 | }, 1088 | { 1089 | "type": "module_pack", 1090 | "named": true 1091 | }, 1092 | { 1093 | "type": "number", 1094 | "named": true 1095 | }, 1096 | { 1097 | "type": "or_pattern", 1098 | "named": true 1099 | }, 1100 | { 1101 | "type": "parenthesized_pattern", 1102 | "named": true 1103 | }, 1104 | { 1105 | "type": "polyvar_pattern", 1106 | "named": true 1107 | }, 1108 | { 1109 | "type": "polyvar_type_pattern", 1110 | "named": true 1111 | }, 1112 | { 1113 | "type": "range_pattern", 1114 | "named": true 1115 | }, 1116 | { 1117 | "type": "record_pattern", 1118 | "named": true 1119 | }, 1120 | { 1121 | "type": "string", 1122 | "named": true 1123 | }, 1124 | { 1125 | "type": "template_string", 1126 | "named": true 1127 | }, 1128 | { 1129 | "type": "true", 1130 | "named": true 1131 | }, 1132 | { 1133 | "type": "tuple_pattern", 1134 | "named": true 1135 | }, 1136 | { 1137 | "type": "unit", 1138 | "named": true 1139 | }, 1140 | { 1141 | "type": "value_identifier", 1142 | "named": true 1143 | }, 1144 | { 1145 | "type": "variant_pattern", 1146 | "named": true 1147 | } 1148 | ] 1149 | } 1150 | }, 1151 | { 1152 | "type": "expression_statement", 1153 | "named": true, 1154 | "fields": {}, 1155 | "children": { 1156 | "multiple": false, 1157 | "required": true, 1158 | "types": [ 1159 | { 1160 | "type": "expression", 1161 | "named": true 1162 | } 1163 | ] 1164 | } 1165 | }, 1166 | { 1167 | "type": "extension_expression", 1168 | "named": true, 1169 | "fields": {}, 1170 | "children": { 1171 | "multiple": true, 1172 | "required": true, 1173 | "types": [ 1174 | { 1175 | "type": "comment", 1176 | "named": true 1177 | }, 1178 | { 1179 | "type": "extension_identifier", 1180 | "named": true 1181 | }, 1182 | { 1183 | "type": "statement", 1184 | "named": true 1185 | } 1186 | ] 1187 | } 1188 | }, 1189 | { 1190 | "type": "extension_identifier", 1191 | "named": true, 1192 | "fields": {} 1193 | }, 1194 | { 1195 | "type": "external_declaration", 1196 | "named": true, 1197 | "fields": {}, 1198 | "children": { 1199 | "multiple": true, 1200 | "required": true, 1201 | "types": [ 1202 | { 1203 | "type": "string", 1204 | "named": true 1205 | }, 1206 | { 1207 | "type": "type_annotation", 1208 | "named": true 1209 | }, 1210 | { 1211 | "type": "value_identifier", 1212 | "named": true 1213 | } 1214 | ] 1215 | } 1216 | }, 1217 | { 1218 | "type": "field", 1219 | "named": true, 1220 | "fields": {}, 1221 | "children": { 1222 | "multiple": true, 1223 | "required": true, 1224 | "types": [ 1225 | { 1226 | "type": "_type", 1227 | "named": true 1228 | }, 1229 | { 1230 | "type": "decorator", 1231 | "named": true 1232 | }, 1233 | { 1234 | "type": "expression", 1235 | "named": true 1236 | }, 1237 | { 1238 | "type": "property_identifier", 1239 | "named": true 1240 | } 1241 | ] 1242 | } 1243 | }, 1244 | { 1245 | "type": "for_expression", 1246 | "named": true, 1247 | "fields": {}, 1248 | "children": { 1249 | "multiple": true, 1250 | "required": true, 1251 | "types": [ 1252 | { 1253 | "type": "expression", 1254 | "named": true 1255 | }, 1256 | { 1257 | "type": "value_identifier", 1258 | "named": true 1259 | } 1260 | ] 1261 | } 1262 | }, 1263 | { 1264 | "type": "formal_parameters", 1265 | "named": true, 1266 | "fields": {}, 1267 | "children": { 1268 | "multiple": true, 1269 | "required": false, 1270 | "types": [ 1271 | { 1272 | "type": "array_pattern", 1273 | "named": true 1274 | }, 1275 | { 1276 | "type": "as_aliasing", 1277 | "named": true 1278 | }, 1279 | { 1280 | "type": "character", 1281 | "named": true 1282 | }, 1283 | { 1284 | "type": "exception_pattern", 1285 | "named": true 1286 | }, 1287 | { 1288 | "type": "false", 1289 | "named": true 1290 | }, 1291 | { 1292 | "type": "lazy_pattern", 1293 | "named": true 1294 | }, 1295 | { 1296 | "type": "list_pattern", 1297 | "named": true 1298 | }, 1299 | { 1300 | "type": "module_pack", 1301 | "named": true 1302 | }, 1303 | { 1304 | "type": "number", 1305 | "named": true 1306 | }, 1307 | { 1308 | "type": "or_pattern", 1309 | "named": true 1310 | }, 1311 | { 1312 | "type": "parameter", 1313 | "named": true 1314 | }, 1315 | { 1316 | "type": "parenthesized_pattern", 1317 | "named": true 1318 | }, 1319 | { 1320 | "type": "polyvar_pattern", 1321 | "named": true 1322 | }, 1323 | { 1324 | "type": "polyvar_type_pattern", 1325 | "named": true 1326 | }, 1327 | { 1328 | "type": "range_pattern", 1329 | "named": true 1330 | }, 1331 | { 1332 | "type": "record_pattern", 1333 | "named": true 1334 | }, 1335 | { 1336 | "type": "string", 1337 | "named": true 1338 | }, 1339 | { 1340 | "type": "template_string", 1341 | "named": true 1342 | }, 1343 | { 1344 | "type": "true", 1345 | "named": true 1346 | }, 1347 | { 1348 | "type": "tuple_pattern", 1349 | "named": true 1350 | }, 1351 | { 1352 | "type": "type_annotation", 1353 | "named": true 1354 | }, 1355 | { 1356 | "type": "unit", 1357 | "named": true 1358 | }, 1359 | { 1360 | "type": "value_identifier", 1361 | "named": true 1362 | }, 1363 | { 1364 | "type": "variant_pattern", 1365 | "named": true 1366 | } 1367 | ] 1368 | } 1369 | }, 1370 | { 1371 | "type": "function", 1372 | "named": true, 1373 | "fields": { 1374 | "body": { 1375 | "multiple": false, 1376 | "required": true, 1377 | "types": [ 1378 | { 1379 | "type": "expression", 1380 | "named": true 1381 | } 1382 | ] 1383 | }, 1384 | "parameter": { 1385 | "multiple": false, 1386 | "required": false, 1387 | "types": [ 1388 | { 1389 | "type": "value_identifier", 1390 | "named": true 1391 | } 1392 | ] 1393 | }, 1394 | "parameters": { 1395 | "multiple": false, 1396 | "required": false, 1397 | "types": [ 1398 | { 1399 | "type": "formal_parameters", 1400 | "named": true 1401 | } 1402 | ] 1403 | }, 1404 | "return_type": { 1405 | "multiple": false, 1406 | "required": false, 1407 | "types": [ 1408 | { 1409 | "type": "type_annotation", 1410 | "named": true 1411 | } 1412 | ] 1413 | } 1414 | }, 1415 | "children": { 1416 | "multiple": true, 1417 | "required": false, 1418 | "types": [ 1419 | { 1420 | "type": "decorator", 1421 | "named": true 1422 | } 1423 | ] 1424 | } 1425 | }, 1426 | { 1427 | "type": "function_type", 1428 | "named": true, 1429 | "fields": {}, 1430 | "children": { 1431 | "multiple": true, 1432 | "required": true, 1433 | "types": [ 1434 | { 1435 | "type": "_type", 1436 | "named": true 1437 | }, 1438 | { 1439 | "type": "function_type_parameters", 1440 | "named": true 1441 | } 1442 | ] 1443 | } 1444 | }, 1445 | { 1446 | "type": "function_type_parameters", 1447 | "named": true, 1448 | "fields": {}, 1449 | "children": { 1450 | "multiple": true, 1451 | "required": false, 1452 | "types": [ 1453 | { 1454 | "type": "generic_type", 1455 | "named": true 1456 | }, 1457 | { 1458 | "type": "module_pack", 1459 | "named": true 1460 | }, 1461 | { 1462 | "type": "object_type", 1463 | "named": true 1464 | }, 1465 | { 1466 | "type": "parameter", 1467 | "named": true 1468 | }, 1469 | { 1470 | "type": "polymorphic_type", 1471 | "named": true 1472 | }, 1473 | { 1474 | "type": "polyvar_type", 1475 | "named": true 1476 | }, 1477 | { 1478 | "type": "tuple_type", 1479 | "named": true 1480 | }, 1481 | { 1482 | "type": "type_identifier", 1483 | "named": true 1484 | }, 1485 | { 1486 | "type": "type_identifier_path", 1487 | "named": true 1488 | }, 1489 | { 1490 | "type": "unit", 1491 | "named": true 1492 | }, 1493 | { 1494 | "type": "unit_type", 1495 | "named": true 1496 | } 1497 | ] 1498 | } 1499 | }, 1500 | { 1501 | "type": "functor", 1502 | "named": true, 1503 | "fields": { 1504 | "body": { 1505 | "multiple": false, 1506 | "required": true, 1507 | "types": [ 1508 | { 1509 | "type": "block", 1510 | "named": true 1511 | }, 1512 | { 1513 | "type": "extension_expression", 1514 | "named": true 1515 | }, 1516 | { 1517 | "type": "functor", 1518 | "named": true 1519 | }, 1520 | { 1521 | "type": "module_expression", 1522 | "named": true 1523 | } 1524 | ] 1525 | }, 1526 | "parameters": { 1527 | "multiple": false, 1528 | "required": true, 1529 | "types": [ 1530 | { 1531 | "type": "functor_parameters", 1532 | "named": true 1533 | } 1534 | ] 1535 | }, 1536 | "return_module_type": { 1537 | "multiple": false, 1538 | "required": false, 1539 | "types": [ 1540 | { 1541 | "type": "module_type_annotation", 1542 | "named": true 1543 | } 1544 | ] 1545 | } 1546 | } 1547 | }, 1548 | { 1549 | "type": "functor_parameter", 1550 | "named": true, 1551 | "fields": {}, 1552 | "children": { 1553 | "multiple": true, 1554 | "required": true, 1555 | "types": [ 1556 | { 1557 | "type": "module_identifier", 1558 | "named": true 1559 | }, 1560 | { 1561 | "type": "module_type_annotation", 1562 | "named": true 1563 | } 1564 | ] 1565 | } 1566 | }, 1567 | { 1568 | "type": "functor_parameters", 1569 | "named": true, 1570 | "fields": {}, 1571 | "children": { 1572 | "multiple": true, 1573 | "required": false, 1574 | "types": [ 1575 | { 1576 | "type": "functor_parameter", 1577 | "named": true 1578 | } 1579 | ] 1580 | } 1581 | }, 1582 | { 1583 | "type": "functor_use", 1584 | "named": true, 1585 | "fields": {}, 1586 | "children": { 1587 | "multiple": true, 1588 | "required": true, 1589 | "types": [ 1590 | { 1591 | "type": "arguments", 1592 | "named": true 1593 | }, 1594 | { 1595 | "type": "module_primary_expression", 1596 | "named": true 1597 | } 1598 | ] 1599 | } 1600 | }, 1601 | { 1602 | "type": "generic_type", 1603 | "named": true, 1604 | "fields": {}, 1605 | "children": { 1606 | "multiple": true, 1607 | "required": true, 1608 | "types": [ 1609 | { 1610 | "type": "as_aliasing_type", 1611 | "named": true 1612 | }, 1613 | { 1614 | "type": "type_arguments", 1615 | "named": true 1616 | }, 1617 | { 1618 | "type": "type_identifier", 1619 | "named": true 1620 | }, 1621 | { 1622 | "type": "type_identifier_path", 1623 | "named": true 1624 | } 1625 | ] 1626 | } 1627 | }, 1628 | { 1629 | "type": "guard", 1630 | "named": true, 1631 | "fields": {}, 1632 | "children": { 1633 | "multiple": false, 1634 | "required": true, 1635 | "types": [ 1636 | { 1637 | "type": "expression", 1638 | "named": true 1639 | } 1640 | ] 1641 | } 1642 | }, 1643 | { 1644 | "type": "if_expression", 1645 | "named": true, 1646 | "fields": {}, 1647 | "children": { 1648 | "multiple": true, 1649 | "required": true, 1650 | "types": [ 1651 | { 1652 | "type": "else_clause", 1653 | "named": true 1654 | }, 1655 | { 1656 | "type": "else_if_clause", 1657 | "named": true 1658 | }, 1659 | { 1660 | "type": "expression", 1661 | "named": true 1662 | } 1663 | ] 1664 | } 1665 | }, 1666 | { 1667 | "type": "include_statement", 1668 | "named": true, 1669 | "fields": {}, 1670 | "children": { 1671 | "multiple": false, 1672 | "required": true, 1673 | "types": [ 1674 | { 1675 | "type": "module_expression", 1676 | "named": true 1677 | } 1678 | ] 1679 | } 1680 | }, 1681 | { 1682 | "type": "jsx_attribute", 1683 | "named": true, 1684 | "fields": {}, 1685 | "children": { 1686 | "multiple": true, 1687 | "required": true, 1688 | "types": [ 1689 | { 1690 | "type": "jsx_expression", 1691 | "named": true 1692 | }, 1693 | { 1694 | "type": "primary_expression", 1695 | "named": true 1696 | }, 1697 | { 1698 | "type": "property_identifier", 1699 | "named": true 1700 | } 1701 | ] 1702 | } 1703 | }, 1704 | { 1705 | "type": "jsx_closing_element", 1706 | "named": true, 1707 | "fields": { 1708 | "name": { 1709 | "multiple": false, 1710 | "required": true, 1711 | "types": [ 1712 | { 1713 | "type": "jsx_identifier", 1714 | "named": true 1715 | }, 1716 | { 1717 | "type": "nested_jsx_identifier", 1718 | "named": true 1719 | } 1720 | ] 1721 | } 1722 | } 1723 | }, 1724 | { 1725 | "type": "jsx_element", 1726 | "named": true, 1727 | "fields": { 1728 | "close_tag": { 1729 | "multiple": false, 1730 | "required": true, 1731 | "types": [ 1732 | { 1733 | "type": "jsx_closing_element", 1734 | "named": true 1735 | } 1736 | ] 1737 | }, 1738 | "open_tag": { 1739 | "multiple": false, 1740 | "required": true, 1741 | "types": [ 1742 | { 1743 | "type": "jsx_opening_element", 1744 | "named": true 1745 | } 1746 | ] 1747 | } 1748 | }, 1749 | "children": { 1750 | "multiple": true, 1751 | "required": false, 1752 | "types": [ 1753 | { 1754 | "type": "block", 1755 | "named": true 1756 | }, 1757 | { 1758 | "type": "character", 1759 | "named": true 1760 | }, 1761 | { 1762 | "type": "jsx_element", 1763 | "named": true 1764 | }, 1765 | { 1766 | "type": "jsx_fragment", 1767 | "named": true 1768 | }, 1769 | { 1770 | "type": "jsx_self_closing_element", 1771 | "named": true 1772 | }, 1773 | { 1774 | "type": "member_expression", 1775 | "named": true 1776 | }, 1777 | { 1778 | "type": "number", 1779 | "named": true 1780 | }, 1781 | { 1782 | "type": "spread_element", 1783 | "named": true 1784 | }, 1785 | { 1786 | "type": "string", 1787 | "named": true 1788 | }, 1789 | { 1790 | "type": "template_string", 1791 | "named": true 1792 | }, 1793 | { 1794 | "type": "value_identifier", 1795 | "named": true 1796 | }, 1797 | { 1798 | "type": "value_identifier_path", 1799 | "named": true 1800 | } 1801 | ] 1802 | } 1803 | }, 1804 | { 1805 | "type": "jsx_expression", 1806 | "named": true, 1807 | "fields": {}, 1808 | "children": { 1809 | "multiple": true, 1810 | "required": false, 1811 | "types": [ 1812 | { 1813 | "type": "comment", 1814 | "named": true 1815 | }, 1816 | { 1817 | "type": "spread_element", 1818 | "named": true 1819 | }, 1820 | { 1821 | "type": "statement", 1822 | "named": true 1823 | } 1824 | ] 1825 | } 1826 | }, 1827 | { 1828 | "type": "jsx_fragment", 1829 | "named": true, 1830 | "fields": {}, 1831 | "children": { 1832 | "multiple": true, 1833 | "required": false, 1834 | "types": [ 1835 | { 1836 | "type": "block", 1837 | "named": true 1838 | }, 1839 | { 1840 | "type": "character", 1841 | "named": true 1842 | }, 1843 | { 1844 | "type": "jsx_element", 1845 | "named": true 1846 | }, 1847 | { 1848 | "type": "jsx_fragment", 1849 | "named": true 1850 | }, 1851 | { 1852 | "type": "jsx_self_closing_element", 1853 | "named": true 1854 | }, 1855 | { 1856 | "type": "member_expression", 1857 | "named": true 1858 | }, 1859 | { 1860 | "type": "number", 1861 | "named": true 1862 | }, 1863 | { 1864 | "type": "spread_element", 1865 | "named": true 1866 | }, 1867 | { 1868 | "type": "string", 1869 | "named": true 1870 | }, 1871 | { 1872 | "type": "template_string", 1873 | "named": true 1874 | }, 1875 | { 1876 | "type": "value_identifier", 1877 | "named": true 1878 | }, 1879 | { 1880 | "type": "value_identifier_path", 1881 | "named": true 1882 | } 1883 | ] 1884 | } 1885 | }, 1886 | { 1887 | "type": "jsx_identifier", 1888 | "named": true, 1889 | "fields": {} 1890 | }, 1891 | { 1892 | "type": "jsx_opening_element", 1893 | "named": true, 1894 | "fields": { 1895 | "attribute": { 1896 | "multiple": true, 1897 | "required": false, 1898 | "types": [ 1899 | { 1900 | "type": "jsx_attribute", 1901 | "named": true 1902 | }, 1903 | { 1904 | "type": "jsx_expression", 1905 | "named": true 1906 | } 1907 | ] 1908 | }, 1909 | "name": { 1910 | "multiple": false, 1911 | "required": true, 1912 | "types": [ 1913 | { 1914 | "type": "jsx_identifier", 1915 | "named": true 1916 | }, 1917 | { 1918 | "type": "nested_jsx_identifier", 1919 | "named": true 1920 | } 1921 | ] 1922 | } 1923 | } 1924 | }, 1925 | { 1926 | "type": "jsx_self_closing_element", 1927 | "named": true, 1928 | "fields": { 1929 | "attribute": { 1930 | "multiple": true, 1931 | "required": false, 1932 | "types": [ 1933 | { 1934 | "type": "jsx_attribute", 1935 | "named": true 1936 | }, 1937 | { 1938 | "type": "jsx_expression", 1939 | "named": true 1940 | } 1941 | ] 1942 | }, 1943 | "name": { 1944 | "multiple": false, 1945 | "required": true, 1946 | "types": [ 1947 | { 1948 | "type": "jsx_identifier", 1949 | "named": true 1950 | }, 1951 | { 1952 | "type": "nested_jsx_identifier", 1953 | "named": true 1954 | } 1955 | ] 1956 | } 1957 | } 1958 | }, 1959 | { 1960 | "type": "labeled_argument", 1961 | "named": true, 1962 | "fields": { 1963 | "label": { 1964 | "multiple": false, 1965 | "required": true, 1966 | "types": [ 1967 | { 1968 | "type": "value_identifier", 1969 | "named": true 1970 | } 1971 | ] 1972 | }, 1973 | "type": { 1974 | "multiple": false, 1975 | "required": false, 1976 | "types": [ 1977 | { 1978 | "type": "type_annotation", 1979 | "named": true 1980 | } 1981 | ] 1982 | }, 1983 | "value": { 1984 | "multiple": false, 1985 | "required": false, 1986 | "types": [ 1987 | { 1988 | "type": "expression", 1989 | "named": true 1990 | } 1991 | ] 1992 | } 1993 | }, 1994 | "children": { 1995 | "multiple": true, 1996 | "required": false, 1997 | "types": [ 1998 | { 1999 | "type": "decorator", 2000 | "named": true 2001 | } 2002 | ] 2003 | } 2004 | }, 2005 | { 2006 | "type": "labeled_parameter", 2007 | "named": true, 2008 | "fields": { 2009 | "default_value": { 2010 | "multiple": true, 2011 | "required": false, 2012 | "types": [ 2013 | { 2014 | "type": "=", 2015 | "named": false 2016 | }, 2017 | { 2018 | "type": "?", 2019 | "named": false 2020 | }, 2021 | { 2022 | "type": "expression", 2023 | "named": true 2024 | } 2025 | ] 2026 | } 2027 | }, 2028 | "children": { 2029 | "multiple": true, 2030 | "required": true, 2031 | "types": [ 2032 | { 2033 | "type": "as_aliasing", 2034 | "named": true 2035 | }, 2036 | { 2037 | "type": "type_annotation", 2038 | "named": true 2039 | }, 2040 | { 2041 | "type": "value_identifier", 2042 | "named": true 2043 | } 2044 | ] 2045 | } 2046 | }, 2047 | { 2048 | "type": "lazy_expression", 2049 | "named": true, 2050 | "fields": {}, 2051 | "children": { 2052 | "multiple": false, 2053 | "required": true, 2054 | "types": [ 2055 | { 2056 | "type": "expression", 2057 | "named": true 2058 | } 2059 | ] 2060 | } 2061 | }, 2062 | { 2063 | "type": "lazy_pattern", 2064 | "named": true, 2065 | "fields": {}, 2066 | "children": { 2067 | "multiple": false, 2068 | "required": true, 2069 | "types": [ 2070 | { 2071 | "type": "array_pattern", 2072 | "named": true 2073 | }, 2074 | { 2075 | "type": "character", 2076 | "named": true 2077 | }, 2078 | { 2079 | "type": "false", 2080 | "named": true 2081 | }, 2082 | { 2083 | "type": "list_pattern", 2084 | "named": true 2085 | }, 2086 | { 2087 | "type": "number", 2088 | "named": true 2089 | }, 2090 | { 2091 | "type": "parenthesized_pattern", 2092 | "named": true 2093 | }, 2094 | { 2095 | "type": "polyvar_pattern", 2096 | "named": true 2097 | }, 2098 | { 2099 | "type": "polyvar_type_pattern", 2100 | "named": true 2101 | }, 2102 | { 2103 | "type": "record_pattern", 2104 | "named": true 2105 | }, 2106 | { 2107 | "type": "string", 2108 | "named": true 2109 | }, 2110 | { 2111 | "type": "template_string", 2112 | "named": true 2113 | }, 2114 | { 2115 | "type": "true", 2116 | "named": true 2117 | }, 2118 | { 2119 | "type": "tuple_pattern", 2120 | "named": true 2121 | }, 2122 | { 2123 | "type": "value_identifier", 2124 | "named": true 2125 | }, 2126 | { 2127 | "type": "variant_pattern", 2128 | "named": true 2129 | } 2130 | ] 2131 | } 2132 | }, 2133 | { 2134 | "type": "let_binding", 2135 | "named": true, 2136 | "fields": { 2137 | "body": { 2138 | "multiple": false, 2139 | "required": false, 2140 | "types": [ 2141 | { 2142 | "type": "expression", 2143 | "named": true 2144 | } 2145 | ] 2146 | }, 2147 | "pattern": { 2148 | "multiple": true, 2149 | "required": true, 2150 | "types": [ 2151 | { 2152 | "type": "array_pattern", 2153 | "named": true 2154 | }, 2155 | { 2156 | "type": "as_aliasing", 2157 | "named": true 2158 | }, 2159 | { 2160 | "type": "character", 2161 | "named": true 2162 | }, 2163 | { 2164 | "type": "exception_pattern", 2165 | "named": true 2166 | }, 2167 | { 2168 | "type": "false", 2169 | "named": true 2170 | }, 2171 | { 2172 | "type": "lazy_pattern", 2173 | "named": true 2174 | }, 2175 | { 2176 | "type": "list_pattern", 2177 | "named": true 2178 | }, 2179 | { 2180 | "type": "module_pack", 2181 | "named": true 2182 | }, 2183 | { 2184 | "type": "number", 2185 | "named": true 2186 | }, 2187 | { 2188 | "type": "or_pattern", 2189 | "named": true 2190 | }, 2191 | { 2192 | "type": "parenthesized_pattern", 2193 | "named": true 2194 | }, 2195 | { 2196 | "type": "polyvar_pattern", 2197 | "named": true 2198 | }, 2199 | { 2200 | "type": "polyvar_type_pattern", 2201 | "named": true 2202 | }, 2203 | { 2204 | "type": "range_pattern", 2205 | "named": true 2206 | }, 2207 | { 2208 | "type": "record_pattern", 2209 | "named": true 2210 | }, 2211 | { 2212 | "type": "string", 2213 | "named": true 2214 | }, 2215 | { 2216 | "type": "template_string", 2217 | "named": true 2218 | }, 2219 | { 2220 | "type": "true", 2221 | "named": true 2222 | }, 2223 | { 2224 | "type": "tuple_pattern", 2225 | "named": true 2226 | }, 2227 | { 2228 | "type": "unit", 2229 | "named": true 2230 | }, 2231 | { 2232 | "type": "value_identifier", 2233 | "named": true 2234 | }, 2235 | { 2236 | "type": "variant_pattern", 2237 | "named": true 2238 | } 2239 | ] 2240 | } 2241 | }, 2242 | "children": { 2243 | "multiple": true, 2244 | "required": false, 2245 | "types": [ 2246 | { 2247 | "type": "decorator", 2248 | "named": true 2249 | }, 2250 | { 2251 | "type": "type_annotation", 2252 | "named": true 2253 | } 2254 | ] 2255 | } 2256 | }, 2257 | { 2258 | "type": "let_declaration", 2259 | "named": true, 2260 | "fields": {}, 2261 | "children": { 2262 | "multiple": true, 2263 | "required": true, 2264 | "types": [ 2265 | { 2266 | "type": "decorator", 2267 | "named": true 2268 | }, 2269 | { 2270 | "type": "let_binding", 2271 | "named": true 2272 | } 2273 | ] 2274 | } 2275 | }, 2276 | { 2277 | "type": "list", 2278 | "named": true, 2279 | "fields": {}, 2280 | "children": { 2281 | "multiple": true, 2282 | "required": false, 2283 | "types": [ 2284 | { 2285 | "type": "decorator", 2286 | "named": true 2287 | }, 2288 | { 2289 | "type": "expression", 2290 | "named": true 2291 | }, 2292 | { 2293 | "type": "spread_element", 2294 | "named": true 2295 | } 2296 | ] 2297 | } 2298 | }, 2299 | { 2300 | "type": "list_pattern", 2301 | "named": true, 2302 | "fields": {}, 2303 | "children": { 2304 | "multiple": true, 2305 | "required": false, 2306 | "types": [ 2307 | { 2308 | "type": "array_pattern", 2309 | "named": true 2310 | }, 2311 | { 2312 | "type": "as_aliasing", 2313 | "named": true 2314 | }, 2315 | { 2316 | "type": "character", 2317 | "named": true 2318 | }, 2319 | { 2320 | "type": "decorator", 2321 | "named": true 2322 | }, 2323 | { 2324 | "type": "exception_pattern", 2325 | "named": true 2326 | }, 2327 | { 2328 | "type": "false", 2329 | "named": true 2330 | }, 2331 | { 2332 | "type": "lazy_pattern", 2333 | "named": true 2334 | }, 2335 | { 2336 | "type": "list_pattern", 2337 | "named": true 2338 | }, 2339 | { 2340 | "type": "module_pack", 2341 | "named": true 2342 | }, 2343 | { 2344 | "type": "number", 2345 | "named": true 2346 | }, 2347 | { 2348 | "type": "or_pattern", 2349 | "named": true 2350 | }, 2351 | { 2352 | "type": "parenthesized_pattern", 2353 | "named": true 2354 | }, 2355 | { 2356 | "type": "polyvar_pattern", 2357 | "named": true 2358 | }, 2359 | { 2360 | "type": "polyvar_type_pattern", 2361 | "named": true 2362 | }, 2363 | { 2364 | "type": "range_pattern", 2365 | "named": true 2366 | }, 2367 | { 2368 | "type": "record_pattern", 2369 | "named": true 2370 | }, 2371 | { 2372 | "type": "spread_pattern", 2373 | "named": true 2374 | }, 2375 | { 2376 | "type": "string", 2377 | "named": true 2378 | }, 2379 | { 2380 | "type": "template_string", 2381 | "named": true 2382 | }, 2383 | { 2384 | "type": "true", 2385 | "named": true 2386 | }, 2387 | { 2388 | "type": "tuple_pattern", 2389 | "named": true 2390 | }, 2391 | { 2392 | "type": "unit", 2393 | "named": true 2394 | }, 2395 | { 2396 | "type": "value_identifier", 2397 | "named": true 2398 | }, 2399 | { 2400 | "type": "variant_pattern", 2401 | "named": true 2402 | } 2403 | ] 2404 | } 2405 | }, 2406 | { 2407 | "type": "member_expression", 2408 | "named": true, 2409 | "fields": { 2410 | "module": { 2411 | "multiple": false, 2412 | "required": false, 2413 | "types": [ 2414 | { 2415 | "type": "module_identifier", 2416 | "named": true 2417 | } 2418 | ] 2419 | }, 2420 | "property": { 2421 | "multiple": false, 2422 | "required": true, 2423 | "types": [ 2424 | { 2425 | "type": "property_identifier", 2426 | "named": true 2427 | } 2428 | ] 2429 | }, 2430 | "record": { 2431 | "multiple": false, 2432 | "required": true, 2433 | "types": [ 2434 | { 2435 | "type": "primary_expression", 2436 | "named": true 2437 | } 2438 | ] 2439 | } 2440 | } 2441 | }, 2442 | { 2443 | "type": "module_binding", 2444 | "named": true, 2445 | "fields": { 2446 | "definition": { 2447 | "multiple": false, 2448 | "required": false, 2449 | "types": [ 2450 | { 2451 | "type": "block", 2452 | "named": true 2453 | }, 2454 | { 2455 | "type": "extension_expression", 2456 | "named": true 2457 | }, 2458 | { 2459 | "type": "functor", 2460 | "named": true 2461 | }, 2462 | { 2463 | "type": "module_expression", 2464 | "named": true 2465 | } 2466 | ] 2467 | }, 2468 | "name": { 2469 | "multiple": false, 2470 | "required": true, 2471 | "types": [ 2472 | { 2473 | "type": "module_identifier", 2474 | "named": true 2475 | }, 2476 | { 2477 | "type": "type_identifier", 2478 | "named": true 2479 | } 2480 | ] 2481 | }, 2482 | "signature": { 2483 | "multiple": false, 2484 | "required": false, 2485 | "types": [ 2486 | { 2487 | "type": "block", 2488 | "named": true 2489 | }, 2490 | { 2491 | "type": "functor", 2492 | "named": true 2493 | }, 2494 | { 2495 | "type": "module_expression", 2496 | "named": true 2497 | } 2498 | ] 2499 | } 2500 | } 2501 | }, 2502 | { 2503 | "type": "module_declaration", 2504 | "named": true, 2505 | "fields": {}, 2506 | "children": { 2507 | "multiple": true, 2508 | "required": true, 2509 | "types": [ 2510 | { 2511 | "type": "module_binding", 2512 | "named": true 2513 | } 2514 | ] 2515 | } 2516 | }, 2517 | { 2518 | "type": "module_identifier", 2519 | "named": true, 2520 | "fields": {} 2521 | }, 2522 | { 2523 | "type": "module_identifier_path", 2524 | "named": true, 2525 | "fields": {}, 2526 | "children": { 2527 | "multiple": true, 2528 | "required": true, 2529 | "types": [ 2530 | { 2531 | "type": "module_primary_expression", 2532 | "named": true 2533 | } 2534 | ] 2535 | } 2536 | }, 2537 | { 2538 | "type": "module_pack", 2539 | "named": true, 2540 | "fields": {}, 2541 | "children": { 2542 | "multiple": true, 2543 | "required": true, 2544 | "types": [ 2545 | { 2546 | "type": "block", 2547 | "named": true 2548 | }, 2549 | { 2550 | "type": "extension_expression", 2551 | "named": true 2552 | }, 2553 | { 2554 | "type": "functor", 2555 | "named": true 2556 | }, 2557 | { 2558 | "type": "module_expression", 2559 | "named": true 2560 | }, 2561 | { 2562 | "type": "module_type_annotation", 2563 | "named": true 2564 | }, 2565 | { 2566 | "type": "type_identifier_path", 2567 | "named": true 2568 | } 2569 | ] 2570 | } 2571 | }, 2572 | { 2573 | "type": "module_type_annotation", 2574 | "named": true, 2575 | "fields": {}, 2576 | "children": { 2577 | "multiple": false, 2578 | "required": true, 2579 | "types": [ 2580 | { 2581 | "type": "block", 2582 | "named": true 2583 | }, 2584 | { 2585 | "type": "module_expression", 2586 | "named": true 2587 | } 2588 | ] 2589 | } 2590 | }, 2591 | { 2592 | "type": "module_type_constraint", 2593 | "named": true, 2594 | "fields": {}, 2595 | "children": { 2596 | "multiple": true, 2597 | "required": true, 2598 | "types": [ 2599 | { 2600 | "type": "constrain_module", 2601 | "named": true 2602 | }, 2603 | { 2604 | "type": "constrain_type", 2605 | "named": true 2606 | }, 2607 | { 2608 | "type": "module_expression", 2609 | "named": true 2610 | } 2611 | ] 2612 | } 2613 | }, 2614 | { 2615 | "type": "module_type_of", 2616 | "named": true, 2617 | "fields": {}, 2618 | "children": { 2619 | "multiple": false, 2620 | "required": true, 2621 | "types": [ 2622 | { 2623 | "type": "block", 2624 | "named": true 2625 | }, 2626 | { 2627 | "type": "module_expression", 2628 | "named": true 2629 | } 2630 | ] 2631 | } 2632 | }, 2633 | { 2634 | "type": "module_unpack", 2635 | "named": true, 2636 | "fields": {}, 2637 | "children": { 2638 | "multiple": true, 2639 | "required": true, 2640 | "types": [ 2641 | { 2642 | "type": "call_expression", 2643 | "named": true 2644 | }, 2645 | { 2646 | "type": "extension_expression", 2647 | "named": true 2648 | }, 2649 | { 2650 | "type": "member_expression", 2651 | "named": true 2652 | }, 2653 | { 2654 | "type": "module_type_annotation", 2655 | "named": true 2656 | }, 2657 | { 2658 | "type": "value_identifier", 2659 | "named": true 2660 | }, 2661 | { 2662 | "type": "value_identifier_path", 2663 | "named": true 2664 | } 2665 | ] 2666 | } 2667 | }, 2668 | { 2669 | "type": "mutation_expression", 2670 | "named": true, 2671 | "fields": {}, 2672 | "children": { 2673 | "multiple": true, 2674 | "required": true, 2675 | "types": [ 2676 | { 2677 | "type": "expression", 2678 | "named": true 2679 | }, 2680 | { 2681 | "type": "member_expression", 2682 | "named": true 2683 | }, 2684 | { 2685 | "type": "subscript_expression", 2686 | "named": true 2687 | }, 2688 | { 2689 | "type": "value_identifier", 2690 | "named": true 2691 | } 2692 | ] 2693 | } 2694 | }, 2695 | { 2696 | "type": "nested_jsx_identifier", 2697 | "named": true, 2698 | "fields": {}, 2699 | "children": { 2700 | "multiple": true, 2701 | "required": true, 2702 | "types": [ 2703 | { 2704 | "type": "jsx_identifier", 2705 | "named": true 2706 | }, 2707 | { 2708 | "type": "nested_jsx_identifier", 2709 | "named": true 2710 | } 2711 | ] 2712 | } 2713 | }, 2714 | { 2715 | "type": "nested_variant_identifier", 2716 | "named": true, 2717 | "fields": {}, 2718 | "children": { 2719 | "multiple": true, 2720 | "required": true, 2721 | "types": [ 2722 | { 2723 | "type": "module_primary_expression", 2724 | "named": true 2725 | }, 2726 | { 2727 | "type": "variant_identifier", 2728 | "named": true 2729 | } 2730 | ] 2731 | } 2732 | }, 2733 | { 2734 | "type": "object", 2735 | "named": true, 2736 | "fields": {}, 2737 | "children": { 2738 | "multiple": true, 2739 | "required": false, 2740 | "types": [ 2741 | { 2742 | "type": "field", 2743 | "named": true 2744 | } 2745 | ] 2746 | } 2747 | }, 2748 | { 2749 | "type": "object_type", 2750 | "named": true, 2751 | "fields": {}, 2752 | "children": { 2753 | "multiple": true, 2754 | "required": false, 2755 | "types": [ 2756 | { 2757 | "type": "as_aliasing_type", 2758 | "named": true 2759 | }, 2760 | { 2761 | "type": "field", 2762 | "named": true 2763 | } 2764 | ] 2765 | } 2766 | }, 2767 | { 2768 | "type": "open_statement", 2769 | "named": true, 2770 | "fields": {}, 2771 | "children": { 2772 | "multiple": false, 2773 | "required": true, 2774 | "types": [ 2775 | { 2776 | "type": "module_expression", 2777 | "named": true 2778 | } 2779 | ] 2780 | } 2781 | }, 2782 | { 2783 | "type": "or_pattern", 2784 | "named": true, 2785 | "fields": {}, 2786 | "children": { 2787 | "multiple": true, 2788 | "required": true, 2789 | "types": [ 2790 | { 2791 | "type": "array_pattern", 2792 | "named": true 2793 | }, 2794 | { 2795 | "type": "as_aliasing", 2796 | "named": true 2797 | }, 2798 | { 2799 | "type": "character", 2800 | "named": true 2801 | }, 2802 | { 2803 | "type": "exception_pattern", 2804 | "named": true 2805 | }, 2806 | { 2807 | "type": "false", 2808 | "named": true 2809 | }, 2810 | { 2811 | "type": "lazy_pattern", 2812 | "named": true 2813 | }, 2814 | { 2815 | "type": "list_pattern", 2816 | "named": true 2817 | }, 2818 | { 2819 | "type": "module_pack", 2820 | "named": true 2821 | }, 2822 | { 2823 | "type": "number", 2824 | "named": true 2825 | }, 2826 | { 2827 | "type": "or_pattern", 2828 | "named": true 2829 | }, 2830 | { 2831 | "type": "parenthesized_pattern", 2832 | "named": true 2833 | }, 2834 | { 2835 | "type": "polyvar_pattern", 2836 | "named": true 2837 | }, 2838 | { 2839 | "type": "polyvar_type_pattern", 2840 | "named": true 2841 | }, 2842 | { 2843 | "type": "range_pattern", 2844 | "named": true 2845 | }, 2846 | { 2847 | "type": "record_pattern", 2848 | "named": true 2849 | }, 2850 | { 2851 | "type": "string", 2852 | "named": true 2853 | }, 2854 | { 2855 | "type": "template_string", 2856 | "named": true 2857 | }, 2858 | { 2859 | "type": "true", 2860 | "named": true 2861 | }, 2862 | { 2863 | "type": "tuple_pattern", 2864 | "named": true 2865 | }, 2866 | { 2867 | "type": "unit", 2868 | "named": true 2869 | }, 2870 | { 2871 | "type": "value_identifier", 2872 | "named": true 2873 | }, 2874 | { 2875 | "type": "variant_pattern", 2876 | "named": true 2877 | } 2878 | ] 2879 | } 2880 | }, 2881 | { 2882 | "type": "parameter", 2883 | "named": true, 2884 | "fields": {}, 2885 | "children": { 2886 | "multiple": true, 2887 | "required": true, 2888 | "types": [ 2889 | { 2890 | "type": "_type", 2891 | "named": true 2892 | }, 2893 | { 2894 | "type": "abstract_type", 2895 | "named": true 2896 | }, 2897 | { 2898 | "type": "array_pattern", 2899 | "named": true 2900 | }, 2901 | { 2902 | "type": "as_aliasing", 2903 | "named": true 2904 | }, 2905 | { 2906 | "type": "character", 2907 | "named": true 2908 | }, 2909 | { 2910 | "type": "decorator", 2911 | "named": true 2912 | }, 2913 | { 2914 | "type": "exception_pattern", 2915 | "named": true 2916 | }, 2917 | { 2918 | "type": "false", 2919 | "named": true 2920 | }, 2921 | { 2922 | "type": "labeled_parameter", 2923 | "named": true 2924 | }, 2925 | { 2926 | "type": "lazy_pattern", 2927 | "named": true 2928 | }, 2929 | { 2930 | "type": "list_pattern", 2931 | "named": true 2932 | }, 2933 | { 2934 | "type": "number", 2935 | "named": true 2936 | }, 2937 | { 2938 | "type": "or_pattern", 2939 | "named": true 2940 | }, 2941 | { 2942 | "type": "parenthesized_pattern", 2943 | "named": true 2944 | }, 2945 | { 2946 | "type": "polyvar_pattern", 2947 | "named": true 2948 | }, 2949 | { 2950 | "type": "polyvar_type_pattern", 2951 | "named": true 2952 | }, 2953 | { 2954 | "type": "range_pattern", 2955 | "named": true 2956 | }, 2957 | { 2958 | "type": "record_pattern", 2959 | "named": true 2960 | }, 2961 | { 2962 | "type": "string", 2963 | "named": true 2964 | }, 2965 | { 2966 | "type": "template_string", 2967 | "named": true 2968 | }, 2969 | { 2970 | "type": "true", 2971 | "named": true 2972 | }, 2973 | { 2974 | "type": "tuple_pattern", 2975 | "named": true 2976 | }, 2977 | { 2978 | "type": "type_annotation", 2979 | "named": true 2980 | }, 2981 | { 2982 | "type": "uncurry", 2983 | "named": true 2984 | }, 2985 | { 2986 | "type": "value_identifier", 2987 | "named": true 2988 | }, 2989 | { 2990 | "type": "variant_pattern", 2991 | "named": true 2992 | } 2993 | ] 2994 | } 2995 | }, 2996 | { 2997 | "type": "parenthesized_expression", 2998 | "named": true, 2999 | "fields": {}, 3000 | "children": { 3001 | "multiple": true, 3002 | "required": true, 3003 | "types": [ 3004 | { 3005 | "type": "decorator", 3006 | "named": true 3007 | }, 3008 | { 3009 | "type": "expression", 3010 | "named": true 3011 | }, 3012 | { 3013 | "type": "type_annotation", 3014 | "named": true 3015 | } 3016 | ] 3017 | } 3018 | }, 3019 | { 3020 | "type": "parenthesized_module_expression", 3021 | "named": true, 3022 | "fields": {}, 3023 | "children": { 3024 | "multiple": true, 3025 | "required": true, 3026 | "types": [ 3027 | { 3028 | "type": "module_expression", 3029 | "named": true 3030 | }, 3031 | { 3032 | "type": "module_type_annotation", 3033 | "named": true 3034 | } 3035 | ] 3036 | } 3037 | }, 3038 | { 3039 | "type": "parenthesized_pattern", 3040 | "named": true, 3041 | "fields": {}, 3042 | "children": { 3043 | "multiple": true, 3044 | "required": true, 3045 | "types": [ 3046 | { 3047 | "type": "array_pattern", 3048 | "named": true 3049 | }, 3050 | { 3051 | "type": "as_aliasing", 3052 | "named": true 3053 | }, 3054 | { 3055 | "type": "character", 3056 | "named": true 3057 | }, 3058 | { 3059 | "type": "exception_pattern", 3060 | "named": true 3061 | }, 3062 | { 3063 | "type": "false", 3064 | "named": true 3065 | }, 3066 | { 3067 | "type": "lazy_pattern", 3068 | "named": true 3069 | }, 3070 | { 3071 | "type": "list_pattern", 3072 | "named": true 3073 | }, 3074 | { 3075 | "type": "module_pack", 3076 | "named": true 3077 | }, 3078 | { 3079 | "type": "number", 3080 | "named": true 3081 | }, 3082 | { 3083 | "type": "or_pattern", 3084 | "named": true 3085 | }, 3086 | { 3087 | "type": "parenthesized_pattern", 3088 | "named": true 3089 | }, 3090 | { 3091 | "type": "polyvar_pattern", 3092 | "named": true 3093 | }, 3094 | { 3095 | "type": "polyvar_type_pattern", 3096 | "named": true 3097 | }, 3098 | { 3099 | "type": "range_pattern", 3100 | "named": true 3101 | }, 3102 | { 3103 | "type": "record_pattern", 3104 | "named": true 3105 | }, 3106 | { 3107 | "type": "string", 3108 | "named": true 3109 | }, 3110 | { 3111 | "type": "template_string", 3112 | "named": true 3113 | }, 3114 | { 3115 | "type": "true", 3116 | "named": true 3117 | }, 3118 | { 3119 | "type": "tuple_pattern", 3120 | "named": true 3121 | }, 3122 | { 3123 | "type": "unit", 3124 | "named": true 3125 | }, 3126 | { 3127 | "type": "value_identifier", 3128 | "named": true 3129 | }, 3130 | { 3131 | "type": "variant_pattern", 3132 | "named": true 3133 | } 3134 | ] 3135 | } 3136 | }, 3137 | { 3138 | "type": "pipe_expression", 3139 | "named": true, 3140 | "fields": {}, 3141 | "children": { 3142 | "multiple": true, 3143 | "required": true, 3144 | "types": [ 3145 | { 3146 | "type": "block", 3147 | "named": true 3148 | }, 3149 | { 3150 | "type": "primary_expression", 3151 | "named": true 3152 | } 3153 | ] 3154 | } 3155 | }, 3156 | { 3157 | "type": "polymorphic_type", 3158 | "named": true, 3159 | "fields": {}, 3160 | "children": { 3161 | "multiple": true, 3162 | "required": true, 3163 | "types": [ 3164 | { 3165 | "type": "abstract_type", 3166 | "named": true 3167 | }, 3168 | { 3169 | "type": "function_type", 3170 | "named": true 3171 | }, 3172 | { 3173 | "type": "generic_type", 3174 | "named": true 3175 | }, 3176 | { 3177 | "type": "module_pack", 3178 | "named": true 3179 | }, 3180 | { 3181 | "type": "object_type", 3182 | "named": true 3183 | }, 3184 | { 3185 | "type": "polymorphic_type", 3186 | "named": true 3187 | }, 3188 | { 3189 | "type": "polyvar_type", 3190 | "named": true 3191 | }, 3192 | { 3193 | "type": "tuple_type", 3194 | "named": true 3195 | }, 3196 | { 3197 | "type": "type_identifier", 3198 | "named": true 3199 | }, 3200 | { 3201 | "type": "type_identifier_path", 3202 | "named": true 3203 | }, 3204 | { 3205 | "type": "unit", 3206 | "named": true 3207 | }, 3208 | { 3209 | "type": "unit_type", 3210 | "named": true 3211 | } 3212 | ] 3213 | } 3214 | }, 3215 | { 3216 | "type": "polyvar", 3217 | "named": true, 3218 | "fields": {}, 3219 | "children": { 3220 | "multiple": true, 3221 | "required": true, 3222 | "types": [ 3223 | { 3224 | "type": "arguments", 3225 | "named": true 3226 | }, 3227 | { 3228 | "type": "polyvar_identifier", 3229 | "named": true 3230 | } 3231 | ] 3232 | } 3233 | }, 3234 | { 3235 | "type": "polyvar_declaration", 3236 | "named": true, 3237 | "fields": {}, 3238 | "children": { 3239 | "multiple": true, 3240 | "required": false, 3241 | "types": [ 3242 | { 3243 | "type": "decorator", 3244 | "named": true 3245 | }, 3246 | { 3247 | "type": "function_type", 3248 | "named": true 3249 | }, 3250 | { 3251 | "type": "generic_type", 3252 | "named": true 3253 | }, 3254 | { 3255 | "type": "module_pack", 3256 | "named": true 3257 | }, 3258 | { 3259 | "type": "object_type", 3260 | "named": true 3261 | }, 3262 | { 3263 | "type": "polymorphic_type", 3264 | "named": true 3265 | }, 3266 | { 3267 | "type": "polyvar_identifier", 3268 | "named": true 3269 | }, 3270 | { 3271 | "type": "polyvar_parameters", 3272 | "named": true 3273 | }, 3274 | { 3275 | "type": "polyvar_type", 3276 | "named": true 3277 | }, 3278 | { 3279 | "type": "tuple_type", 3280 | "named": true 3281 | }, 3282 | { 3283 | "type": "type_identifier", 3284 | "named": true 3285 | }, 3286 | { 3287 | "type": "type_identifier_path", 3288 | "named": true 3289 | }, 3290 | { 3291 | "type": "unit", 3292 | "named": true 3293 | }, 3294 | { 3295 | "type": "unit_type", 3296 | "named": true 3297 | } 3298 | ] 3299 | } 3300 | }, 3301 | { 3302 | "type": "polyvar_identifier", 3303 | "named": true, 3304 | "fields": {}, 3305 | "children": { 3306 | "multiple": false, 3307 | "required": false, 3308 | "types": [ 3309 | { 3310 | "type": "polyvar_string", 3311 | "named": true 3312 | } 3313 | ] 3314 | } 3315 | }, 3316 | { 3317 | "type": "polyvar_parameters", 3318 | "named": true, 3319 | "fields": {}, 3320 | "children": { 3321 | "multiple": true, 3322 | "required": true, 3323 | "types": [ 3324 | { 3325 | "type": "_type", 3326 | "named": true 3327 | } 3328 | ] 3329 | } 3330 | }, 3331 | { 3332 | "type": "polyvar_pattern", 3333 | "named": true, 3334 | "fields": {}, 3335 | "children": { 3336 | "multiple": true, 3337 | "required": true, 3338 | "types": [ 3339 | { 3340 | "type": "formal_parameters", 3341 | "named": true 3342 | }, 3343 | { 3344 | "type": "polyvar_identifier", 3345 | "named": true 3346 | } 3347 | ] 3348 | } 3349 | }, 3350 | { 3351 | "type": "polyvar_string", 3352 | "named": true, 3353 | "fields": {}, 3354 | "children": { 3355 | "multiple": true, 3356 | "required": false, 3357 | "types": [ 3358 | { 3359 | "type": "escape_sequence", 3360 | "named": true 3361 | }, 3362 | { 3363 | "type": "string_fragment", 3364 | "named": true 3365 | } 3366 | ] 3367 | } 3368 | }, 3369 | { 3370 | "type": "polyvar_type", 3371 | "named": true, 3372 | "fields": {}, 3373 | "children": { 3374 | "multiple": true, 3375 | "required": true, 3376 | "types": [ 3377 | { 3378 | "type": "as_aliasing_type", 3379 | "named": true 3380 | }, 3381 | { 3382 | "type": "decorator", 3383 | "named": true 3384 | }, 3385 | { 3386 | "type": "polyvar_declaration", 3387 | "named": true 3388 | } 3389 | ] 3390 | } 3391 | }, 3392 | { 3393 | "type": "polyvar_type_pattern", 3394 | "named": true, 3395 | "fields": {}, 3396 | "children": { 3397 | "multiple": false, 3398 | "required": false, 3399 | "types": [ 3400 | { 3401 | "type": "type_identifier", 3402 | "named": true 3403 | }, 3404 | { 3405 | "type": "type_identifier_path", 3406 | "named": true 3407 | } 3408 | ] 3409 | } 3410 | }, 3411 | { 3412 | "type": "property_identifier", 3413 | "named": true, 3414 | "fields": {}, 3415 | "children": { 3416 | "multiple": true, 3417 | "required": false, 3418 | "types": [ 3419 | { 3420 | "type": "escape_sequence", 3421 | "named": true 3422 | }, 3423 | { 3424 | "type": "module_primary_expression", 3425 | "named": true 3426 | }, 3427 | { 3428 | "type": "string_fragment", 3429 | "named": true 3430 | }, 3431 | { 3432 | "type": "value_identifier", 3433 | "named": true 3434 | } 3435 | ] 3436 | } 3437 | }, 3438 | { 3439 | "type": "range_pattern", 3440 | "named": true, 3441 | "fields": {}, 3442 | "children": { 3443 | "multiple": true, 3444 | "required": true, 3445 | "types": [ 3446 | { 3447 | "type": "character", 3448 | "named": true 3449 | }, 3450 | { 3451 | "type": "false", 3452 | "named": true 3453 | }, 3454 | { 3455 | "type": "number", 3456 | "named": true 3457 | }, 3458 | { 3459 | "type": "string", 3460 | "named": true 3461 | }, 3462 | { 3463 | "type": "template_string", 3464 | "named": true 3465 | }, 3466 | { 3467 | "type": "true", 3468 | "named": true 3469 | } 3470 | ] 3471 | } 3472 | }, 3473 | { 3474 | "type": "record", 3475 | "named": true, 3476 | "fields": {}, 3477 | "children": { 3478 | "multiple": true, 3479 | "required": false, 3480 | "types": [ 3481 | { 3482 | "type": "property_identifier", 3483 | "named": true 3484 | }, 3485 | { 3486 | "type": "record_field", 3487 | "named": true 3488 | }, 3489 | { 3490 | "type": "spread_element", 3491 | "named": true 3492 | } 3493 | ] 3494 | } 3495 | }, 3496 | { 3497 | "type": "record_field", 3498 | "named": true, 3499 | "fields": {}, 3500 | "children": { 3501 | "multiple": true, 3502 | "required": true, 3503 | "types": [ 3504 | { 3505 | "type": "expression", 3506 | "named": true 3507 | }, 3508 | { 3509 | "type": "property_identifier", 3510 | "named": true 3511 | } 3512 | ] 3513 | } 3514 | }, 3515 | { 3516 | "type": "record_pattern", 3517 | "named": true, 3518 | "fields": {}, 3519 | "children": { 3520 | "multiple": true, 3521 | "required": true, 3522 | "types": [ 3523 | { 3524 | "type": "array_pattern", 3525 | "named": true 3526 | }, 3527 | { 3528 | "type": "as_aliasing", 3529 | "named": true 3530 | }, 3531 | { 3532 | "type": "character", 3533 | "named": true 3534 | }, 3535 | { 3536 | "type": "exception_pattern", 3537 | "named": true 3538 | }, 3539 | { 3540 | "type": "false", 3541 | "named": true 3542 | }, 3543 | { 3544 | "type": "lazy_pattern", 3545 | "named": true 3546 | }, 3547 | { 3548 | "type": "list_pattern", 3549 | "named": true 3550 | }, 3551 | { 3552 | "type": "module_pack", 3553 | "named": true 3554 | }, 3555 | { 3556 | "type": "number", 3557 | "named": true 3558 | }, 3559 | { 3560 | "type": "or_pattern", 3561 | "named": true 3562 | }, 3563 | { 3564 | "type": "parenthesized_pattern", 3565 | "named": true 3566 | }, 3567 | { 3568 | "type": "polyvar_pattern", 3569 | "named": true 3570 | }, 3571 | { 3572 | "type": "polyvar_type_pattern", 3573 | "named": true 3574 | }, 3575 | { 3576 | "type": "range_pattern", 3577 | "named": true 3578 | }, 3579 | { 3580 | "type": "record_pattern", 3581 | "named": true 3582 | }, 3583 | { 3584 | "type": "string", 3585 | "named": true 3586 | }, 3587 | { 3588 | "type": "template_string", 3589 | "named": true 3590 | }, 3591 | { 3592 | "type": "true", 3593 | "named": true 3594 | }, 3595 | { 3596 | "type": "tuple_pattern", 3597 | "named": true 3598 | }, 3599 | { 3600 | "type": "unit", 3601 | "named": true 3602 | }, 3603 | { 3604 | "type": "value_identifier", 3605 | "named": true 3606 | }, 3607 | { 3608 | "type": "value_identifier_path", 3609 | "named": true 3610 | }, 3611 | { 3612 | "type": "variant_pattern", 3613 | "named": true 3614 | } 3615 | ] 3616 | } 3617 | }, 3618 | { 3619 | "type": "record_type", 3620 | "named": true, 3621 | "fields": {}, 3622 | "children": { 3623 | "multiple": true, 3624 | "required": false, 3625 | "types": [ 3626 | { 3627 | "type": "record_type_field", 3628 | "named": true 3629 | } 3630 | ] 3631 | } 3632 | }, 3633 | { 3634 | "type": "record_type_field", 3635 | "named": true, 3636 | "fields": {}, 3637 | "children": { 3638 | "multiple": true, 3639 | "required": true, 3640 | "types": [ 3641 | { 3642 | "type": "decorator", 3643 | "named": true 3644 | }, 3645 | { 3646 | "type": "property_identifier", 3647 | "named": true 3648 | }, 3649 | { 3650 | "type": "type_annotation", 3651 | "named": true 3652 | } 3653 | ] 3654 | } 3655 | }, 3656 | { 3657 | "type": "sequence_expression", 3658 | "named": true, 3659 | "fields": {}, 3660 | "children": { 3661 | "multiple": true, 3662 | "required": true, 3663 | "types": [ 3664 | { 3665 | "type": "comment", 3666 | "named": true 3667 | }, 3668 | { 3669 | "type": "statement", 3670 | "named": true 3671 | } 3672 | ] 3673 | } 3674 | }, 3675 | { 3676 | "type": "source_file", 3677 | "named": true, 3678 | "fields": {}, 3679 | "children": { 3680 | "multiple": true, 3681 | "required": false, 3682 | "types": [ 3683 | { 3684 | "type": "comment", 3685 | "named": true 3686 | }, 3687 | { 3688 | "type": "statement", 3689 | "named": true 3690 | } 3691 | ] 3692 | } 3693 | }, 3694 | { 3695 | "type": "spread_element", 3696 | "named": true, 3697 | "fields": {}, 3698 | "children": { 3699 | "multiple": false, 3700 | "required": true, 3701 | "types": [ 3702 | { 3703 | "type": "expression", 3704 | "named": true 3705 | } 3706 | ] 3707 | } 3708 | }, 3709 | { 3710 | "type": "spread_pattern", 3711 | "named": true, 3712 | "fields": {}, 3713 | "children": { 3714 | "multiple": false, 3715 | "required": true, 3716 | "types": [ 3717 | { 3718 | "type": "array_pattern", 3719 | "named": true 3720 | }, 3721 | { 3722 | "type": "list_pattern", 3723 | "named": true 3724 | }, 3725 | { 3726 | "type": "value_identifier", 3727 | "named": true 3728 | } 3729 | ] 3730 | } 3731 | }, 3732 | { 3733 | "type": "string", 3734 | "named": true, 3735 | "fields": {}, 3736 | "children": { 3737 | "multiple": true, 3738 | "required": false, 3739 | "types": [ 3740 | { 3741 | "type": "escape_sequence", 3742 | "named": true 3743 | }, 3744 | { 3745 | "type": "string_fragment", 3746 | "named": true 3747 | } 3748 | ] 3749 | } 3750 | }, 3751 | { 3752 | "type": "subscript_expression", 3753 | "named": true, 3754 | "fields": { 3755 | "index": { 3756 | "multiple": false, 3757 | "required": true, 3758 | "types": [ 3759 | { 3760 | "type": "expression", 3761 | "named": true 3762 | } 3763 | ] 3764 | }, 3765 | "object": { 3766 | "multiple": false, 3767 | "required": true, 3768 | "types": [ 3769 | { 3770 | "type": "primary_expression", 3771 | "named": true 3772 | } 3773 | ] 3774 | } 3775 | } 3776 | }, 3777 | { 3778 | "type": "switch_expression", 3779 | "named": true, 3780 | "fields": {}, 3781 | "children": { 3782 | "multiple": true, 3783 | "required": true, 3784 | "types": [ 3785 | { 3786 | "type": "expression", 3787 | "named": true 3788 | }, 3789 | { 3790 | "type": "switch_match", 3791 | "named": true 3792 | } 3793 | ] 3794 | } 3795 | }, 3796 | { 3797 | "type": "switch_match", 3798 | "named": true, 3799 | "fields": { 3800 | "body": { 3801 | "multiple": false, 3802 | "required": true, 3803 | "types": [ 3804 | { 3805 | "type": "sequence_expression", 3806 | "named": true 3807 | } 3808 | ] 3809 | }, 3810 | "pattern": { 3811 | "multiple": true, 3812 | "required": true, 3813 | "types": [ 3814 | { 3815 | "type": "array_pattern", 3816 | "named": true 3817 | }, 3818 | { 3819 | "type": "as_aliasing", 3820 | "named": true 3821 | }, 3822 | { 3823 | "type": "character", 3824 | "named": true 3825 | }, 3826 | { 3827 | "type": "exception_pattern", 3828 | "named": true 3829 | }, 3830 | { 3831 | "type": "false", 3832 | "named": true 3833 | }, 3834 | { 3835 | "type": "lazy_pattern", 3836 | "named": true 3837 | }, 3838 | { 3839 | "type": "list_pattern", 3840 | "named": true 3841 | }, 3842 | { 3843 | "type": "module_pack", 3844 | "named": true 3845 | }, 3846 | { 3847 | "type": "number", 3848 | "named": true 3849 | }, 3850 | { 3851 | "type": "or_pattern", 3852 | "named": true 3853 | }, 3854 | { 3855 | "type": "parenthesized_pattern", 3856 | "named": true 3857 | }, 3858 | { 3859 | "type": "polyvar_pattern", 3860 | "named": true 3861 | }, 3862 | { 3863 | "type": "polyvar_type_pattern", 3864 | "named": true 3865 | }, 3866 | { 3867 | "type": "range_pattern", 3868 | "named": true 3869 | }, 3870 | { 3871 | "type": "record_pattern", 3872 | "named": true 3873 | }, 3874 | { 3875 | "type": "string", 3876 | "named": true 3877 | }, 3878 | { 3879 | "type": "template_string", 3880 | "named": true 3881 | }, 3882 | { 3883 | "type": "true", 3884 | "named": true 3885 | }, 3886 | { 3887 | "type": "tuple_pattern", 3888 | "named": true 3889 | }, 3890 | { 3891 | "type": "unit", 3892 | "named": true 3893 | }, 3894 | { 3895 | "type": "value_identifier", 3896 | "named": true 3897 | }, 3898 | { 3899 | "type": "variant_pattern", 3900 | "named": true 3901 | } 3902 | ] 3903 | } 3904 | }, 3905 | "children": { 3906 | "multiple": false, 3907 | "required": false, 3908 | "types": [ 3909 | { 3910 | "type": "guard", 3911 | "named": true 3912 | } 3913 | ] 3914 | } 3915 | }, 3916 | { 3917 | "type": "template_string", 3918 | "named": true, 3919 | "fields": {}, 3920 | "children": { 3921 | "multiple": false, 3922 | "required": true, 3923 | "types": [ 3924 | { 3925 | "type": "template_string_content", 3926 | "named": true 3927 | } 3928 | ] 3929 | } 3930 | }, 3931 | { 3932 | "type": "template_string_content", 3933 | "named": true, 3934 | "fields": {}, 3935 | "children": { 3936 | "multiple": true, 3937 | "required": false, 3938 | "types": [ 3939 | { 3940 | "type": "escape_sequence", 3941 | "named": true 3942 | }, 3943 | { 3944 | "type": "template_substitution", 3945 | "named": true 3946 | } 3947 | ] 3948 | } 3949 | }, 3950 | { 3951 | "type": "template_substitution", 3952 | "named": true, 3953 | "fields": {}, 3954 | "children": { 3955 | "multiple": false, 3956 | "required": true, 3957 | "types": [ 3958 | { 3959 | "type": "expression", 3960 | "named": true 3961 | }, 3962 | { 3963 | "type": "value_identifier", 3964 | "named": true 3965 | } 3966 | ] 3967 | } 3968 | }, 3969 | { 3970 | "type": "ternary_expression", 3971 | "named": true, 3972 | "fields": { 3973 | "alternative": { 3974 | "multiple": false, 3975 | "required": true, 3976 | "types": [ 3977 | { 3978 | "type": "expression", 3979 | "named": true 3980 | } 3981 | ] 3982 | }, 3983 | "condition": { 3984 | "multiple": false, 3985 | "required": true, 3986 | "types": [ 3987 | { 3988 | "type": "expression", 3989 | "named": true 3990 | } 3991 | ] 3992 | }, 3993 | "consequence": { 3994 | "multiple": false, 3995 | "required": true, 3996 | "types": [ 3997 | { 3998 | "type": "expression", 3999 | "named": true 4000 | } 4001 | ] 4002 | } 4003 | } 4004 | }, 4005 | { 4006 | "type": "try_expression", 4007 | "named": true, 4008 | "fields": {}, 4009 | "children": { 4010 | "multiple": true, 4011 | "required": true, 4012 | "types": [ 4013 | { 4014 | "type": "block", 4015 | "named": true 4016 | }, 4017 | { 4018 | "type": "primary_expression", 4019 | "named": true 4020 | }, 4021 | { 4022 | "type": "switch_match", 4023 | "named": true 4024 | } 4025 | ] 4026 | } 4027 | }, 4028 | { 4029 | "type": "tuple", 4030 | "named": true, 4031 | "fields": {}, 4032 | "children": { 4033 | "multiple": true, 4034 | "required": true, 4035 | "types": [ 4036 | { 4037 | "type": "decorator", 4038 | "named": true 4039 | }, 4040 | { 4041 | "type": "expression", 4042 | "named": true 4043 | } 4044 | ] 4045 | } 4046 | }, 4047 | { 4048 | "type": "tuple_item_pattern", 4049 | "named": true, 4050 | "fields": {}, 4051 | "children": { 4052 | "multiple": true, 4053 | "required": true, 4054 | "types": [ 4055 | { 4056 | "type": "array_pattern", 4057 | "named": true 4058 | }, 4059 | { 4060 | "type": "as_aliasing", 4061 | "named": true 4062 | }, 4063 | { 4064 | "type": "character", 4065 | "named": true 4066 | }, 4067 | { 4068 | "type": "decorator", 4069 | "named": true 4070 | }, 4071 | { 4072 | "type": "exception_pattern", 4073 | "named": true 4074 | }, 4075 | { 4076 | "type": "false", 4077 | "named": true 4078 | }, 4079 | { 4080 | "type": "lazy_pattern", 4081 | "named": true 4082 | }, 4083 | { 4084 | "type": "list_pattern", 4085 | "named": true 4086 | }, 4087 | { 4088 | "type": "module_pack", 4089 | "named": true 4090 | }, 4091 | { 4092 | "type": "number", 4093 | "named": true 4094 | }, 4095 | { 4096 | "type": "or_pattern", 4097 | "named": true 4098 | }, 4099 | { 4100 | "type": "parenthesized_pattern", 4101 | "named": true 4102 | }, 4103 | { 4104 | "type": "polyvar_pattern", 4105 | "named": true 4106 | }, 4107 | { 4108 | "type": "polyvar_type_pattern", 4109 | "named": true 4110 | }, 4111 | { 4112 | "type": "range_pattern", 4113 | "named": true 4114 | }, 4115 | { 4116 | "type": "record_pattern", 4117 | "named": true 4118 | }, 4119 | { 4120 | "type": "string", 4121 | "named": true 4122 | }, 4123 | { 4124 | "type": "template_string", 4125 | "named": true 4126 | }, 4127 | { 4128 | "type": "true", 4129 | "named": true 4130 | }, 4131 | { 4132 | "type": "tuple_pattern", 4133 | "named": true 4134 | }, 4135 | { 4136 | "type": "type_annotation", 4137 | "named": true 4138 | }, 4139 | { 4140 | "type": "unit", 4141 | "named": true 4142 | }, 4143 | { 4144 | "type": "value_identifier", 4145 | "named": true 4146 | }, 4147 | { 4148 | "type": "variant_pattern", 4149 | "named": true 4150 | } 4151 | ] 4152 | } 4153 | }, 4154 | { 4155 | "type": "tuple_pattern", 4156 | "named": true, 4157 | "fields": {}, 4158 | "children": { 4159 | "multiple": true, 4160 | "required": true, 4161 | "types": [ 4162 | { 4163 | "type": "tuple_item_pattern", 4164 | "named": true 4165 | } 4166 | ] 4167 | } 4168 | }, 4169 | { 4170 | "type": "tuple_type", 4171 | "named": true, 4172 | "fields": {}, 4173 | "children": { 4174 | "multiple": true, 4175 | "required": true, 4176 | "types": [ 4177 | { 4178 | "type": "_type", 4179 | "named": true 4180 | } 4181 | ] 4182 | } 4183 | }, 4184 | { 4185 | "type": "type_annotation", 4186 | "named": true, 4187 | "fields": {}, 4188 | "children": { 4189 | "multiple": true, 4190 | "required": false, 4191 | "types": [ 4192 | { 4193 | "type": "decorator", 4194 | "named": true 4195 | }, 4196 | { 4197 | "type": "function_type", 4198 | "named": true 4199 | }, 4200 | { 4201 | "type": "generic_type", 4202 | "named": true 4203 | }, 4204 | { 4205 | "type": "module_pack", 4206 | "named": true 4207 | }, 4208 | { 4209 | "type": "object_type", 4210 | "named": true 4211 | }, 4212 | { 4213 | "type": "polymorphic_type", 4214 | "named": true 4215 | }, 4216 | { 4217 | "type": "polyvar_type", 4218 | "named": true 4219 | }, 4220 | { 4221 | "type": "tuple_type", 4222 | "named": true 4223 | }, 4224 | { 4225 | "type": "type_identifier", 4226 | "named": true 4227 | }, 4228 | { 4229 | "type": "type_identifier_path", 4230 | "named": true 4231 | }, 4232 | { 4233 | "type": "unit", 4234 | "named": true 4235 | }, 4236 | { 4237 | "type": "unit_type", 4238 | "named": true 4239 | } 4240 | ] 4241 | } 4242 | }, 4243 | { 4244 | "type": "type_arguments", 4245 | "named": true, 4246 | "fields": {}, 4247 | "children": { 4248 | "multiple": true, 4249 | "required": true, 4250 | "types": [ 4251 | { 4252 | "type": "_type", 4253 | "named": true 4254 | } 4255 | ] 4256 | } 4257 | }, 4258 | { 4259 | "type": "type_binding", 4260 | "named": true, 4261 | "fields": { 4262 | "body": { 4263 | "multiple": false, 4264 | "required": false, 4265 | "types": [ 4266 | { 4267 | "type": "_type", 4268 | "named": true 4269 | } 4270 | ] 4271 | }, 4272 | "name": { 4273 | "multiple": false, 4274 | "required": true, 4275 | "types": [ 4276 | { 4277 | "type": "type_identifier", 4278 | "named": true 4279 | }, 4280 | { 4281 | "type": "type_identifier_path", 4282 | "named": true 4283 | } 4284 | ] 4285 | } 4286 | }, 4287 | "children": { 4288 | "multiple": true, 4289 | "required": false, 4290 | "types": [ 4291 | { 4292 | "type": "generic_type", 4293 | "named": true 4294 | }, 4295 | { 4296 | "type": "module_pack", 4297 | "named": true 4298 | }, 4299 | { 4300 | "type": "object_type", 4301 | "named": true 4302 | }, 4303 | { 4304 | "type": "polymorphic_type", 4305 | "named": true 4306 | }, 4307 | { 4308 | "type": "polyvar_type", 4309 | "named": true 4310 | }, 4311 | { 4312 | "type": "tuple_type", 4313 | "named": true 4314 | }, 4315 | { 4316 | "type": "type_constraint", 4317 | "named": true 4318 | }, 4319 | { 4320 | "type": "type_identifier", 4321 | "named": true 4322 | }, 4323 | { 4324 | "type": "type_identifier_path", 4325 | "named": true 4326 | }, 4327 | { 4328 | "type": "type_parameters", 4329 | "named": true 4330 | }, 4331 | { 4332 | "type": "unit", 4333 | "named": true 4334 | }, 4335 | { 4336 | "type": "unit_type", 4337 | "named": true 4338 | } 4339 | ] 4340 | } 4341 | }, 4342 | { 4343 | "type": "type_constraint", 4344 | "named": true, 4345 | "fields": {}, 4346 | "children": { 4347 | "multiple": true, 4348 | "required": true, 4349 | "types": [ 4350 | { 4351 | "type": "_type", 4352 | "named": true 4353 | } 4354 | ] 4355 | } 4356 | }, 4357 | { 4358 | "type": "type_declaration", 4359 | "named": true, 4360 | "fields": {}, 4361 | "children": { 4362 | "multiple": true, 4363 | "required": true, 4364 | "types": [ 4365 | { 4366 | "type": "decorator", 4367 | "named": true 4368 | }, 4369 | { 4370 | "type": "type_binding", 4371 | "named": true 4372 | } 4373 | ] 4374 | } 4375 | }, 4376 | { 4377 | "type": "type_identifier", 4378 | "named": true, 4379 | "fields": {} 4380 | }, 4381 | { 4382 | "type": "type_identifier_path", 4383 | "named": true, 4384 | "fields": {}, 4385 | "children": { 4386 | "multiple": true, 4387 | "required": true, 4388 | "types": [ 4389 | { 4390 | "type": "module_primary_expression", 4391 | "named": true 4392 | }, 4393 | { 4394 | "type": "type_identifier", 4395 | "named": true 4396 | } 4397 | ] 4398 | } 4399 | }, 4400 | { 4401 | "type": "type_parameters", 4402 | "named": true, 4403 | "fields": {}, 4404 | "children": { 4405 | "multiple": true, 4406 | "required": true, 4407 | "types": [ 4408 | { 4409 | "type": "type_identifier", 4410 | "named": true 4411 | } 4412 | ] 4413 | } 4414 | }, 4415 | { 4416 | "type": "unary_expression", 4417 | "named": true, 4418 | "fields": { 4419 | "argument": { 4420 | "multiple": false, 4421 | "required": true, 4422 | "types": [ 4423 | { 4424 | "type": "expression", 4425 | "named": true 4426 | } 4427 | ] 4428 | }, 4429 | "operator": { 4430 | "multiple": false, 4431 | "required": true, 4432 | "types": [ 4433 | { 4434 | "type": "!", 4435 | "named": false 4436 | }, 4437 | { 4438 | "type": "+", 4439 | "named": false 4440 | }, 4441 | { 4442 | "type": "+.", 4443 | "named": false 4444 | }, 4445 | { 4446 | "type": "-", 4447 | "named": false 4448 | }, 4449 | { 4450 | "type": "-.", 4451 | "named": false 4452 | } 4453 | ] 4454 | } 4455 | } 4456 | }, 4457 | { 4458 | "type": "uncurry", 4459 | "named": true, 4460 | "fields": {} 4461 | }, 4462 | { 4463 | "type": "unit", 4464 | "named": true, 4465 | "fields": {} 4466 | }, 4467 | { 4468 | "type": "value_identifier", 4469 | "named": true, 4470 | "fields": {} 4471 | }, 4472 | { 4473 | "type": "value_identifier_path", 4474 | "named": true, 4475 | "fields": {}, 4476 | "children": { 4477 | "multiple": true, 4478 | "required": true, 4479 | "types": [ 4480 | { 4481 | "type": "module_primary_expression", 4482 | "named": true 4483 | }, 4484 | { 4485 | "type": "value_identifier", 4486 | "named": true 4487 | } 4488 | ] 4489 | } 4490 | }, 4491 | { 4492 | "type": "variant", 4493 | "named": true, 4494 | "fields": {}, 4495 | "children": { 4496 | "multiple": true, 4497 | "required": true, 4498 | "types": [ 4499 | { 4500 | "type": "arguments", 4501 | "named": true 4502 | }, 4503 | { 4504 | "type": "nested_variant_identifier", 4505 | "named": true 4506 | }, 4507 | { 4508 | "type": "variant_identifier", 4509 | "named": true 4510 | } 4511 | ] 4512 | } 4513 | }, 4514 | { 4515 | "type": "variant_declaration", 4516 | "named": true, 4517 | "fields": {}, 4518 | "children": { 4519 | "multiple": true, 4520 | "required": true, 4521 | "types": [ 4522 | { 4523 | "type": "decorator", 4524 | "named": true 4525 | }, 4526 | { 4527 | "type": "type_annotation", 4528 | "named": true 4529 | }, 4530 | { 4531 | "type": "variant_identifier", 4532 | "named": true 4533 | }, 4534 | { 4535 | "type": "variant_parameters", 4536 | "named": true 4537 | } 4538 | ] 4539 | } 4540 | }, 4541 | { 4542 | "type": "variant_identifier", 4543 | "named": true, 4544 | "fields": {} 4545 | }, 4546 | { 4547 | "type": "variant_parameters", 4548 | "named": true, 4549 | "fields": {}, 4550 | "children": { 4551 | "multiple": true, 4552 | "required": true, 4553 | "types": [ 4554 | { 4555 | "type": "_type", 4556 | "named": true 4557 | } 4558 | ] 4559 | } 4560 | }, 4561 | { 4562 | "type": "variant_pattern", 4563 | "named": true, 4564 | "fields": {}, 4565 | "children": { 4566 | "multiple": true, 4567 | "required": true, 4568 | "types": [ 4569 | { 4570 | "type": "formal_parameters", 4571 | "named": true 4572 | }, 4573 | { 4574 | "type": "nested_variant_identifier", 4575 | "named": true 4576 | }, 4577 | { 4578 | "type": "variant_identifier", 4579 | "named": true 4580 | } 4581 | ] 4582 | } 4583 | }, 4584 | { 4585 | "type": "variant_type", 4586 | "named": true, 4587 | "fields": {}, 4588 | "children": { 4589 | "multiple": true, 4590 | "required": true, 4591 | "types": [ 4592 | { 4593 | "type": "variant_declaration", 4594 | "named": true 4595 | } 4596 | ] 4597 | } 4598 | }, 4599 | { 4600 | "type": "while_expression", 4601 | "named": true, 4602 | "fields": {}, 4603 | "children": { 4604 | "multiple": true, 4605 | "required": true, 4606 | "types": [ 4607 | { 4608 | "type": "expression", 4609 | "named": true 4610 | } 4611 | ] 4612 | } 4613 | }, 4614 | { 4615 | "type": "!", 4616 | "named": false 4617 | }, 4618 | { 4619 | "type": "!=", 4620 | "named": false 4621 | }, 4622 | { 4623 | "type": "!==", 4624 | "named": false 4625 | }, 4626 | { 4627 | "type": "\"", 4628 | "named": false 4629 | }, 4630 | { 4631 | "type": "#", 4632 | "named": false 4633 | }, 4634 | { 4635 | "type": "$", 4636 | "named": false 4637 | }, 4638 | { 4639 | "type": "${", 4640 | "named": false 4641 | }, 4642 | { 4643 | "type": "%", 4644 | "named": false 4645 | }, 4646 | { 4647 | "type": "&&", 4648 | "named": false 4649 | }, 4650 | { 4651 | "type": "'", 4652 | "named": false 4653 | }, 4654 | { 4655 | "type": "(", 4656 | "named": false 4657 | }, 4658 | { 4659 | "type": ")", 4660 | "named": false 4661 | }, 4662 | { 4663 | "type": "*", 4664 | "named": false 4665 | }, 4666 | { 4667 | "type": "**", 4668 | "named": false 4669 | }, 4670 | { 4671 | "type": "*.", 4672 | "named": false 4673 | }, 4674 | { 4675 | "type": "+", 4676 | "named": false 4677 | }, 4678 | { 4679 | "type": "++", 4680 | "named": false 4681 | }, 4682 | { 4683 | "type": "+.", 4684 | "named": false 4685 | }, 4686 | { 4687 | "type": "+=", 4688 | "named": false 4689 | }, 4690 | { 4691 | "type": ",", 4692 | "named": false 4693 | }, 4694 | { 4695 | "type": "-", 4696 | "named": false 4697 | }, 4698 | { 4699 | "type": "-.", 4700 | "named": false 4701 | }, 4702 | { 4703 | "type": "->", 4704 | "named": false 4705 | }, 4706 | { 4707 | "type": ".", 4708 | "named": false 4709 | }, 4710 | { 4711 | "type": "..", 4712 | "named": false 4713 | }, 4714 | { 4715 | "type": "...", 4716 | "named": false 4717 | }, 4718 | { 4719 | "type": "/", 4720 | "named": false 4721 | }, 4722 | { 4723 | "type": "/.", 4724 | "named": false 4725 | }, 4726 | { 4727 | "type": ":", 4728 | "named": false 4729 | }, 4730 | { 4731 | "type": ":=", 4732 | "named": false 4733 | }, 4734 | { 4735 | "type": ":>", 4736 | "named": false 4737 | }, 4738 | { 4739 | "type": ";", 4740 | "named": false 4741 | }, 4742 | { 4743 | "type": "<", 4744 | "named": false 4745 | }, 4746 | { 4747 | "type": "<=", 4748 | "named": false 4749 | }, 4750 | { 4751 | "type": "=", 4752 | "named": false 4753 | }, 4754 | { 4755 | "type": "==", 4756 | "named": false 4757 | }, 4758 | { 4759 | "type": "===", 4760 | "named": false 4761 | }, 4762 | { 4763 | "type": "=>", 4764 | "named": false 4765 | }, 4766 | { 4767 | "type": ">", 4768 | "named": false 4769 | }, 4770 | { 4771 | "type": ">=", 4772 | "named": false 4773 | }, 4774 | { 4775 | "type": "?", 4776 | "named": false 4777 | }, 4778 | { 4779 | "type": "@", 4780 | "named": false 4781 | }, 4782 | { 4783 | "type": "@@", 4784 | "named": false 4785 | }, 4786 | { 4787 | "type": "[", 4788 | "named": false 4789 | }, 4790 | { 4791 | "type": "[<", 4792 | "named": false 4793 | }, 4794 | { 4795 | "type": "[>", 4796 | "named": false 4797 | }, 4798 | { 4799 | "type": "\\", 4800 | "named": false 4801 | }, 4802 | { 4803 | "type": "]", 4804 | "named": false 4805 | }, 4806 | { 4807 | "type": "`", 4808 | "named": false 4809 | }, 4810 | { 4811 | "type": "and", 4812 | "named": false 4813 | }, 4814 | { 4815 | "type": "as", 4816 | "named": false 4817 | }, 4818 | { 4819 | "type": "assert", 4820 | "named": false 4821 | }, 4822 | { 4823 | "type": "async", 4824 | "named": false 4825 | }, 4826 | { 4827 | "type": "await", 4828 | "named": false 4829 | }, 4830 | { 4831 | "type": "catch", 4832 | "named": false 4833 | }, 4834 | { 4835 | "type": "comment", 4836 | "named": true 4837 | }, 4838 | { 4839 | "type": "constraint", 4840 | "named": false 4841 | }, 4842 | { 4843 | "type": "downto", 4844 | "named": false 4845 | }, 4846 | { 4847 | "type": "else", 4848 | "named": false 4849 | }, 4850 | { 4851 | "type": "escape_sequence", 4852 | "named": true 4853 | }, 4854 | { 4855 | "type": "exception", 4856 | "named": false 4857 | }, 4858 | { 4859 | "type": "export", 4860 | "named": false 4861 | }, 4862 | { 4863 | "type": "external", 4864 | "named": false 4865 | }, 4866 | { 4867 | "type": "false", 4868 | "named": true 4869 | }, 4870 | { 4871 | "type": "for", 4872 | "named": false 4873 | }, 4874 | { 4875 | "type": "if", 4876 | "named": false 4877 | }, 4878 | { 4879 | "type": "in", 4880 | "named": false 4881 | }, 4882 | { 4883 | "type": "include", 4884 | "named": false 4885 | }, 4886 | { 4887 | "type": "lazy", 4888 | "named": false 4889 | }, 4890 | { 4891 | "type": "let", 4892 | "named": false 4893 | }, 4894 | { 4895 | "type": "module", 4896 | "named": false 4897 | }, 4898 | { 4899 | "type": "mutable", 4900 | "named": false 4901 | }, 4902 | { 4903 | "type": "number", 4904 | "named": true 4905 | }, 4906 | { 4907 | "type": "of", 4908 | "named": false 4909 | }, 4910 | { 4911 | "type": "open", 4912 | "named": false 4913 | }, 4914 | { 4915 | "type": "private", 4916 | "named": false 4917 | }, 4918 | { 4919 | "type": "rec", 4920 | "named": false 4921 | }, 4922 | { 4923 | "type": "string_fragment", 4924 | "named": true 4925 | }, 4926 | { 4927 | "type": "switch", 4928 | "named": false 4929 | }, 4930 | { 4931 | "type": "to", 4932 | "named": false 4933 | }, 4934 | { 4935 | "type": "true", 4936 | "named": true 4937 | }, 4938 | { 4939 | "type": "try", 4940 | "named": false 4941 | }, 4942 | { 4943 | "type": "type", 4944 | "named": false 4945 | }, 4946 | { 4947 | "type": "unit_type", 4948 | "named": true 4949 | }, 4950 | { 4951 | "type": "unpack", 4952 | "named": false 4953 | }, 4954 | { 4955 | "type": "when", 4956 | "named": false 4957 | }, 4958 | { 4959 | "type": "while", 4960 | "named": false 4961 | }, 4962 | { 4963 | "type": "with", 4964 | "named": false 4965 | }, 4966 | { 4967 | "type": "{", 4968 | "named": false 4969 | }, 4970 | { 4971 | "type": "|", 4972 | "named": false 4973 | }, 4974 | { 4975 | "type": "|>", 4976 | "named": false 4977 | }, 4978 | { 4979 | "type": "||", 4980 | "named": false 4981 | }, 4982 | { 4983 | "type": "}", 4984 | "named": false 4985 | }, 4986 | { 4987 | "type": "~", 4988 | "named": false 4989 | } 4990 | ] -------------------------------------------------------------------------------- /tree-sitter-rescript/src/scanner.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | enum TokenType { 6 | NEWLINE, 7 | COMMENT, 8 | NEWLINE_AND_COMMENT, 9 | QUOTE, 10 | BACKTICK, 11 | TEMPLATE_CHARS, 12 | L_PAREN, 13 | R_PAREN, 14 | LIST_CONSTRUCTOR 15 | }; 16 | 17 | typedef struct ScannerState { 18 | int parens_nesting; 19 | bool in_quotes; 20 | bool in_backticks; 21 | bool eof_reported; 22 | } ScannerState; 23 | 24 | void *tree_sitter_rescript_external_scanner_create() { 25 | void* state = malloc(sizeof(ScannerState)); 26 | memset(state, 0, sizeof(ScannerState)); 27 | return state; 28 | } 29 | 30 | void tree_sitter_rescript_external_scanner_destroy(void* state) { 31 | free(state); 32 | } 33 | 34 | void tree_sitter_rescript_external_scanner_reset(void* state) { 35 | memset(state, 0, sizeof(ScannerState)); 36 | } 37 | 38 | unsigned tree_sitter_rescript_external_scanner_serialize(void* state, char *buffer) { 39 | memcpy(buffer, state, sizeof(ScannerState)); 40 | return sizeof(ScannerState); 41 | } 42 | 43 | void tree_sitter_rescript_external_scanner_deserialize(void* state, const char *buffer, unsigned n_bytes) { 44 | memcpy(state, buffer, n_bytes); 45 | } 46 | 47 | static void advance(TSLexer *lexer) { lexer->advance(lexer, false); } 48 | static void skip(TSLexer *lexer) { lexer->advance(lexer, true); } 49 | 50 | static bool is_inline_whitespace(int32_t c) { 51 | return c == ' ' || c == '\t'; 52 | } 53 | 54 | static void scan_whitespace(TSLexer *lexer, bool skip) { 55 | while (iswspace(lexer->lookahead) && !lexer->eof(lexer)) { 56 | lexer->advance(lexer, skip); 57 | } 58 | } 59 | 60 | static void scan_multiline_comment(TSLexer *lexer) { 61 | int level = 1; 62 | advance(lexer); 63 | while (level > 0 && !lexer->eof(lexer)) { 64 | switch (lexer->lookahead) { 65 | case '/': 66 | advance(lexer); 67 | if (lexer->lookahead == '*') 68 | ++level; 69 | else 70 | continue; 71 | 72 | break; 73 | 74 | case '*': 75 | advance(lexer); 76 | if (lexer->lookahead == '/') 77 | --level; 78 | else 79 | continue; 80 | 81 | break; 82 | } 83 | 84 | advance(lexer); 85 | } 86 | } 87 | 88 | static bool scan_comment(TSLexer *lexer) { 89 | if (lexer->lookahead != '/') 90 | return false; 91 | 92 | advance(lexer); 93 | switch (lexer->lookahead) { 94 | case '/': 95 | // Single-line comment 96 | do { 97 | advance(lexer); 98 | } while (lexer->lookahead != '\n'); 99 | return true; 100 | 101 | case '*': 102 | // Multi-line comment 103 | scan_multiline_comment(lexer); 104 | return true; 105 | 106 | default: 107 | // Division, etc 108 | return false; 109 | } 110 | } 111 | 112 | static bool scan_whitespace_and_comments(TSLexer *lexer) { 113 | bool has_comments = false; 114 | while (!lexer->eof(lexer)) { 115 | // Once a comment is found, the subsequent whitespace should not be marked 116 | // as skipped to keep the correct range of the comment node if it will be 117 | // marked so. 118 | bool skip_whitespace = !has_comments; 119 | scan_whitespace(lexer, skip_whitespace); 120 | if (scan_comment(lexer)) { 121 | has_comments = true; 122 | } else { 123 | break; 124 | } 125 | } 126 | 127 | return has_comments; 128 | } 129 | 130 | static bool is_identifier_start(char c) { 131 | return c == '_' || (c >= 'a' && c <= 'z'); 132 | } 133 | 134 | bool tree_sitter_rescript_external_scanner_scan( 135 | void* payload, 136 | TSLexer* lexer, 137 | const bool* valid_symbols 138 | ) { 139 | ScannerState* state = (ScannerState*)payload; 140 | const in_string = state->in_quotes || state->in_backticks; 141 | 142 | while (is_inline_whitespace(lexer->lookahead) && !in_string) { 143 | skip(lexer); 144 | } 145 | 146 | if (valid_symbols[TEMPLATE_CHARS]) { 147 | lexer->result_symbol = TEMPLATE_CHARS; 148 | for (bool has_content = false;; has_content = true) { 149 | lexer->mark_end(lexer); 150 | switch (lexer->lookahead) { 151 | case '`': 152 | state->in_backticks = false; 153 | return has_content; 154 | case '\0': 155 | return false; 156 | case '$': 157 | advance(lexer); 158 | if (lexer->lookahead == '{' || is_identifier_start(lexer->lookahead)) { 159 | return has_content; 160 | } 161 | break; 162 | case '\\': 163 | return has_content; 164 | default: 165 | advance(lexer); 166 | } 167 | } 168 | 169 | return true; 170 | } 171 | 172 | // If a source file missing EOL at EOF, give the last statement a chance: 173 | // report the statement delimiting EOL at the very end of file. Make sure 174 | // it’s done only once, otherwise the scanner will enter dead-lock because 175 | // we report NEWLINE again and again, no matter the lexer is exhausted 176 | // already. 177 | if (valid_symbols[NEWLINE] && lexer->eof(lexer) && !state->eof_reported) { 178 | lexer->result_symbol = NEWLINE; 179 | state->eof_reported = true; 180 | return true; 181 | } 182 | 183 | // Magic ahead! 184 | // We have two types of newline in ReScript. The one which ends the current statement, 185 | // and the one used just for pretty-formatting (e.g. separates variant type values). 186 | // We report only the first one. The second one should be ignored and skipped as 187 | // whitespace. 188 | // What makes things worse is that we can have comments interleaved in statements. 189 | // Tree-sitter gives just one chance to say what type of a token we’re on. We can’t 190 | // say: “I see a significant newline, then I see a comment”. To deal with it, an 191 | // artificial token NEWLINE_AND_COMMENT was introduced. It has the same semantics for 192 | // the AST as simple newline and the same highlighting as a usual comment. 193 | if (valid_symbols[NEWLINE] && lexer->lookahead == '\n') { 194 | bool is_unnested = state->parens_nesting == 0; 195 | lexer->result_symbol = NEWLINE; 196 | lexer->advance(lexer, true); 197 | lexer->mark_end(lexer); 198 | 199 | bool has_comment = scan_whitespace_and_comments(lexer); 200 | if (has_comment && valid_symbols[NEWLINE_AND_COMMENT]) { 201 | lexer->result_symbol = NEWLINE_AND_COMMENT; 202 | lexer->mark_end(lexer); 203 | } 204 | 205 | bool in_multiline_statement = false; 206 | if (lexer->lookahead == '-') { 207 | advance(lexer); 208 | if (lexer->lookahead == '>') { 209 | // Ignore new lines before pipe operator (->) 210 | in_multiline_statement = true; 211 | } 212 | } else if (lexer->lookahead == '|') { 213 | // Ignore new lines before variant declarations and switch matches 214 | in_multiline_statement = true; 215 | } else if (lexer->lookahead == '?' || lexer->lookahead == ':') { 216 | // Ignore new lines before potential ternaries 217 | in_multiline_statement = true; 218 | } else if (lexer->lookahead == '}') { 219 | // Do not report new lines right before block/switch closings to avoid 220 | // parser confustion between a terminated and unterminated statements 221 | // for rules like seq(repeat($._statement), $.statement) 222 | in_multiline_statement = true; 223 | } else if (lexer->lookahead == 'a') { 224 | advance(lexer); 225 | if (lexer->lookahead == 'n') { 226 | advance(lexer); 227 | if (lexer->lookahead == 'd') { 228 | // Ignore new lines before `and` keyword (recursive definition) 229 | in_multiline_statement = true; 230 | } 231 | } 232 | } 233 | 234 | if (in_multiline_statement) { 235 | if (has_comment && valid_symbols[COMMENT]) { 236 | lexer->result_symbol = COMMENT; 237 | return true; 238 | } 239 | } else { 240 | return true; 241 | } 242 | } 243 | 244 | if (!in_string) { 245 | scan_whitespace(lexer, true); 246 | } 247 | 248 | if (valid_symbols[COMMENT] && lexer->lookahead == '/' && !in_string) { 249 | lexer->result_symbol = COMMENT; 250 | if (scan_comment(lexer)) { 251 | lexer->mark_end(lexer); 252 | return true; 253 | } else { 254 | return false; 255 | } 256 | } 257 | 258 | if (valid_symbols[QUOTE] && lexer->lookahead == '"') { 259 | state->in_quotes = !state->in_quotes; 260 | lexer->result_symbol = QUOTE; 261 | lexer->advance(lexer, false); 262 | lexer->mark_end(lexer); 263 | return true; 264 | } 265 | 266 | if (valid_symbols[BACKTICK] && lexer->lookahead == '`') { 267 | state->in_backticks = !state->in_backticks; 268 | lexer->result_symbol = BACKTICK; 269 | lexer->advance(lexer, false); 270 | lexer->mark_end(lexer); 271 | return true; 272 | } 273 | 274 | if (valid_symbols[L_PAREN] && lexer->lookahead == '(') { 275 | ++state->parens_nesting; 276 | lexer->result_symbol = L_PAREN; 277 | lexer->advance(lexer, false); 278 | lexer->mark_end(lexer); 279 | return true; 280 | } 281 | 282 | if (valid_symbols[R_PAREN] && lexer->lookahead == ')') { 283 | --state->parens_nesting; 284 | lexer->result_symbol = R_PAREN; 285 | lexer->advance(lexer, false); 286 | lexer->mark_end(lexer); 287 | return true; 288 | } 289 | 290 | if (valid_symbols[LIST_CONSTRUCTOR]) { 291 | lexer->result_symbol = LIST_CONSTRUCTOR; 292 | if (lexer->lookahead == 'l') { 293 | advance(lexer); 294 | if (lexer->lookahead == 'i') { 295 | advance(lexer); 296 | if (lexer->lookahead == 's') { 297 | advance(lexer); 298 | if (lexer->lookahead == 't') { 299 | advance(lexer); 300 | if (lexer->lookahead == '{') { 301 | lexer->mark_end(lexer); 302 | return true; 303 | } 304 | } 305 | } 306 | } 307 | } 308 | } 309 | 310 | lexer->advance(lexer, iswspace(lexer->lookahead)); 311 | return false; 312 | } 313 | 314 | // vim:sw=2 315 | -------------------------------------------------------------------------------- /tree-sitter-rescript/src/tree_sitter/parser.h: -------------------------------------------------------------------------------- 1 | #ifndef TREE_SITTER_PARSER_H_ 2 | #define TREE_SITTER_PARSER_H_ 3 | 4 | #ifdef __cplusplus 5 | extern "C" { 6 | #endif 7 | 8 | #include 9 | #include 10 | #include 11 | 12 | #define ts_builtin_sym_error ((TSSymbol)-1) 13 | #define ts_builtin_sym_end 0 14 | #define TREE_SITTER_SERIALIZATION_BUFFER_SIZE 1024 15 | 16 | typedef uint16_t TSStateId; 17 | 18 | #ifndef TREE_SITTER_API_H_ 19 | typedef uint16_t TSSymbol; 20 | typedef uint16_t TSFieldId; 21 | typedef struct TSLanguage TSLanguage; 22 | #endif 23 | 24 | typedef struct { 25 | TSFieldId field_id; 26 | uint8_t child_index; 27 | bool inherited; 28 | } TSFieldMapEntry; 29 | 30 | typedef struct { 31 | uint16_t index; 32 | uint16_t length; 33 | } TSFieldMapSlice; 34 | 35 | typedef struct { 36 | bool visible; 37 | bool named; 38 | bool supertype; 39 | } TSSymbolMetadata; 40 | 41 | typedef struct TSLexer TSLexer; 42 | 43 | struct TSLexer { 44 | int32_t lookahead; 45 | TSSymbol result_symbol; 46 | void (*advance)(TSLexer *, bool); 47 | void (*mark_end)(TSLexer *); 48 | uint32_t (*get_column)(TSLexer *); 49 | bool (*is_at_included_range_start)(const TSLexer *); 50 | bool (*eof)(const TSLexer *); 51 | }; 52 | 53 | typedef enum { 54 | TSParseActionTypeShift, 55 | TSParseActionTypeReduce, 56 | TSParseActionTypeAccept, 57 | TSParseActionTypeRecover, 58 | } TSParseActionType; 59 | 60 | typedef union { 61 | struct { 62 | uint8_t type; 63 | TSStateId state; 64 | bool extra; 65 | bool repetition; 66 | } shift; 67 | struct { 68 | uint8_t type; 69 | uint8_t child_count; 70 | TSSymbol symbol; 71 | int16_t dynamic_precedence; 72 | uint16_t production_id; 73 | } reduce; 74 | uint8_t type; 75 | } TSParseAction; 76 | 77 | typedef struct { 78 | uint16_t lex_state; 79 | uint16_t external_lex_state; 80 | } TSLexMode; 81 | 82 | typedef union { 83 | TSParseAction action; 84 | struct { 85 | uint8_t count; 86 | bool reusable; 87 | } entry; 88 | } TSParseActionEntry; 89 | 90 | struct TSLanguage { 91 | uint32_t version; 92 | uint32_t symbol_count; 93 | uint32_t alias_count; 94 | uint32_t token_count; 95 | uint32_t external_token_count; 96 | uint32_t state_count; 97 | uint32_t large_state_count; 98 | uint32_t production_id_count; 99 | uint32_t field_count; 100 | uint16_t max_alias_sequence_length; 101 | const uint16_t *parse_table; 102 | const uint16_t *small_parse_table; 103 | const uint32_t *small_parse_table_map; 104 | const TSParseActionEntry *parse_actions; 105 | const char * const *symbol_names; 106 | const char * const *field_names; 107 | const TSFieldMapSlice *field_map_slices; 108 | const TSFieldMapEntry *field_map_entries; 109 | const TSSymbolMetadata *symbol_metadata; 110 | const TSSymbol *public_symbol_map; 111 | const uint16_t *alias_map; 112 | const TSSymbol *alias_sequences; 113 | const TSLexMode *lex_modes; 114 | bool (*lex_fn)(TSLexer *, TSStateId); 115 | bool (*keyword_lex_fn)(TSLexer *, TSStateId); 116 | TSSymbol keyword_capture_token; 117 | struct { 118 | const bool *states; 119 | const TSSymbol *symbol_map; 120 | void *(*create)(void); 121 | void (*destroy)(void *); 122 | bool (*scan)(void *, TSLexer *, const bool *symbol_whitelist); 123 | unsigned (*serialize)(void *, char *); 124 | void (*deserialize)(void *, const char *, unsigned); 125 | } external_scanner; 126 | }; 127 | 128 | /* 129 | * Lexer Macros 130 | */ 131 | 132 | #define START_LEXER() \ 133 | bool result = false; \ 134 | bool skip = false; \ 135 | bool eof = false; \ 136 | int32_t lookahead; \ 137 | goto start; \ 138 | next_state: \ 139 | lexer->advance(lexer, skip); \ 140 | start: \ 141 | skip = false; \ 142 | lookahead = lexer->lookahead; 143 | 144 | #define ADVANCE(state_value) \ 145 | { \ 146 | state = state_value; \ 147 | goto next_state; \ 148 | } 149 | 150 | #define SKIP(state_value) \ 151 | { \ 152 | skip = true; \ 153 | state = state_value; \ 154 | goto next_state; \ 155 | } 156 | 157 | #define ACCEPT_TOKEN(symbol_value) \ 158 | result = true; \ 159 | lexer->result_symbol = symbol_value; \ 160 | lexer->mark_end(lexer); 161 | 162 | #define END_STATE() return result; 163 | 164 | /* 165 | * Parse Table Macros 166 | */ 167 | 168 | #define SMALL_STATE(id) id - LARGE_STATE_COUNT 169 | 170 | #define STATE(id) id 171 | 172 | #define ACTIONS(id) id 173 | 174 | #define SHIFT(state_value) \ 175 | {{ \ 176 | .shift = { \ 177 | .type = TSParseActionTypeShift, \ 178 | .state = state_value \ 179 | } \ 180 | }} 181 | 182 | #define SHIFT_REPEAT(state_value) \ 183 | {{ \ 184 | .shift = { \ 185 | .type = TSParseActionTypeShift, \ 186 | .state = state_value, \ 187 | .repetition = true \ 188 | } \ 189 | }} 190 | 191 | #define SHIFT_EXTRA() \ 192 | {{ \ 193 | .shift = { \ 194 | .type = TSParseActionTypeShift, \ 195 | .extra = true \ 196 | } \ 197 | }} 198 | 199 | #define REDUCE(symbol_val, child_count_val, ...) \ 200 | {{ \ 201 | .reduce = { \ 202 | .type = TSParseActionTypeReduce, \ 203 | .symbol = symbol_val, \ 204 | .child_count = child_count_val, \ 205 | __VA_ARGS__ \ 206 | }, \ 207 | }} 208 | 209 | #define RECOVER() \ 210 | {{ \ 211 | .type = TSParseActionTypeRecover \ 212 | }} 213 | 214 | #define ACCEPT_INPUT() \ 215 | {{ \ 216 | .type = TSParseActionTypeAccept \ 217 | }} 218 | 219 | #ifdef __cplusplus 220 | } 221 | #endif 222 | 223 | #endif // TREE_SITTER_PARSER_H_ 224 | --------------------------------------------------------------------------------