From f136cafb4182eadfbee6977e6fa9933d399a7259 Mon Sep 17 00:00:00 2001 From: Jeff Date: Mon, 1 Jan 2024 05:20:11 -0500 Subject: [PATCH] Implement collection type --- src/abstract_tree/built_in_value.rs | 85 ++ src/abstract_tree/mod.rs | 9 +- src/abstract_tree/type_definition.rs | 102 +- src/built_in_functions/mod.rs | 19 +- src/lib.rs | 2 +- src/value/mod.rs | 84 +- tree-sitter-dust/grammar.js | 1 + tree-sitter-dust/src/grammar.json | 4 + tree-sitter-dust/src/node-types.json | 4 + tree-sitter-dust/src/parser.c | 2009 +++++++++++++------------- 10 files changed, 1203 insertions(+), 1116 deletions(-) create mode 100644 src/abstract_tree/built_in_value.rs diff --git a/src/abstract_tree/built_in_value.rs b/src/abstract_tree/built_in_value.rs new file mode 100644 index 0000000..bf927ed --- /dev/null +++ b/src/abstract_tree/built_in_value.rs @@ -0,0 +1,85 @@ +use std::{env::args, sync::OnceLock}; + +use serde::{Deserialize, Serialize}; +use tree_sitter::Node; + +use crate::{AbstractTree, BuiltInFunction, Function, List, Map, Result, Type, Value}; + +static ARGS: OnceLock = OnceLock::new(); +static RANDOM: OnceLock = OnceLock::new(); + +#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +pub enum BuiltInValue { + Args, + AssertEqual, + Length, + Output, + Random, +} + +impl BuiltInValue { + fn r#type(&self) -> Type { + match self { + BuiltInValue::Args => Type::list_of(Type::String), + BuiltInValue::AssertEqual => BuiltInFunction::AssertEqual.r#type(), + BuiltInValue::Length => BuiltInFunction::Length.r#type(), + BuiltInValue::Output => BuiltInFunction::Output.r#type(), + BuiltInValue::Random => Type::Map, + } + } + + fn get(&self) -> &Value { + match self { + BuiltInValue::Args => ARGS.get_or_init(|| { + let args = args().map(|arg| Value::String(arg.to_string())).collect(); + + Value::List(List::with_items(args)) + }), + BuiltInValue::AssertEqual => { + &Value::Function(Function::BuiltIn(BuiltInFunction::AssertEqual)) + } + BuiltInValue::Length => &Value::Function(Function::BuiltIn(BuiltInFunction::Length)), + BuiltInValue::Output => &Value::Function(Function::BuiltIn(BuiltInFunction::Output)), + BuiltInValue::Random => RANDOM.get_or_init(|| { + let random_context = Map::new(); + + { + let mut variables = random_context.variables_mut().unwrap(); + + for built_in_function in [BuiltInFunction::RandomBoolean] { + let key = built_in_function.name().to_string(); + let value = Value::Function(Function::BuiltIn(built_in_function)); + let r#type = built_in_function.r#type(); + + variables.insert(key, (value, r#type)); + } + } + + Value::Map(random_context) + }), + } + } +} + +impl AbstractTree for BuiltInValue { + fn from_syntax_node(_source: &str, node: Node, _context: &Map) -> Result { + let built_in_value = match node.kind() { + "args" => BuiltInValue::Args, + "assert_equal" => BuiltInValue::AssertEqual, + "length" => BuiltInValue::Length, + "output" => BuiltInValue::Output, + "random" => BuiltInValue::Random, + _ => todo!(), + }; + + Ok(built_in_value) + } + + fn run(&self, _source: &str, _context: &Map) -> Result { + Ok(self.get().clone()) + } + + fn expected_type(&self, _context: &Map) -> Result { + Ok(self.r#type()) + } +} diff --git a/src/abstract_tree/mod.rs b/src/abstract_tree/mod.rs index 41b8cfb..3f9006d 100644 --- a/src/abstract_tree/mod.rs +++ b/src/abstract_tree/mod.rs @@ -8,6 +8,7 @@ pub mod assignment; pub mod block; +pub mod built_in_value; pub mod expression; pub mod r#for; pub mod function_call; @@ -27,10 +28,10 @@ pub mod r#while; pub mod r#yield; pub use { - assignment::*, block::*, expression::*, function_call::*, function_expression::*, - identifier::*, if_else::*, index::*, index_assignment::IndexAssignment, index_expression::*, - logic::*, math::*, r#for::*, r#match::*, r#while::*, r#yield::*, statement::*, - type_definition::*, value_node::*, + assignment::*, block::*, built_in_value::*, expression::*, function_call::*, + function_expression::*, identifier::*, if_else::*, index::*, index_assignment::IndexAssignment, + index_expression::*, logic::*, math::*, r#for::*, r#match::*, r#while::*, r#yield::*, + statement::*, type_definition::*, value_node::*, }; use tree_sitter::Node; diff --git a/src/abstract_tree/type_definition.rs b/src/abstract_tree/type_definition.rs index 1f4a1a6..2e0d32b 100644 --- a/src/abstract_tree/type_definition.rs +++ b/src/abstract_tree/type_definition.rs @@ -53,6 +53,7 @@ impl Display for TypeDefinition { pub enum Type { Any, Boolean, + Collection, Float, Function { parameter_types: Vec, @@ -84,6 +85,13 @@ impl Type { (Type::Any, _) | (_, Type::Any) | (Type::Boolean, Type::Boolean) + | (Type::Collection, Type::Collection) + | (Type::Collection, Type::List(_)) + | (Type::List(_), Type::Collection) + | (Type::Collection, Type::Map) + | (Type::Map, Type::Collection) + | (Type::Collection, Type::String) + | (Type::String, Type::Collection) | (Type::Float, Type::Float) | (Type::Integer, Type::Integer) | (Type::Map, Type::Map) @@ -165,63 +173,64 @@ impl AbstractTree for Type { let type_node = node.child(0).unwrap(); - let r#type = match type_node.kind() { - "[" => { - let item_type_node = node.child(1).unwrap(); - let item_type = Type::from_syntax_node(source, item_type_node, _context)?; + let r#type = + match type_node.kind() { + "[" => { + let item_type_node = node.child(1).unwrap(); + let item_type = Type::from_syntax_node(source, item_type_node, _context)?; - Type::List(Box::new(item_type)) - } - "any" => Type::Any, - "bool" => Type::Boolean, - "float" => Type::Float, - "(" => { - let child_count = node.child_count(); - let mut parameter_types = Vec::new(); + Type::List(Box::new(item_type)) + } + "any" => Type::Any, + "bool" => Type::Boolean, + "collection" => Type::Collection, + "float" => Type::Float, + "(" => { + let child_count = node.child_count(); + let mut parameter_types = Vec::new(); - for index in 1..child_count - 2 { - let child = node.child(index).unwrap(); + for index in 1..child_count - 2 { + let child = node.child(index).unwrap(); - if child.is_named() { - let parameter_type = Type::from_syntax_node(source, child, _context)?; + if child.is_named() { + let parameter_type = Type::from_syntax_node(source, child, _context)?; - parameter_types.push(parameter_type); + parameter_types.push(parameter_type); + } + } + + let final_node = node.child(child_count - 1).unwrap(); + let return_type = if final_node.is_named() { + Type::from_syntax_node(source, final_node, _context)? + } else { + Type::None + }; + + Type::Function { + parameter_types, + return_type: Box::new(return_type), } } + "int" => Type::Integer, + "map" => Type::Map, + "num" => Type::Number, + "none" => Type::None, + "str" => Type::String, + "option" => { + let inner_type_node = node.child(2).unwrap(); + let inner_type = Type::from_syntax_node(source, inner_type_node, _context)?; - let final_node = node.child(child_count - 1).unwrap(); - let return_type = if final_node.is_named() { - Type::from_syntax_node(source, final_node, _context)? - } else { - Type::None - }; - - Type::Function { - parameter_types, - return_type: Box::new(return_type), + Type::Option(Box::new(inner_type)) } - } - "int" => Type::Integer, - "map" => Type::Map, - "num" => Type::Number, - "none" => Type::None, - "str" => Type::String, - "option" => { - let inner_type_node = node.child(2).unwrap(); - let inner_type = Type::from_syntax_node(source, inner_type_node, _context)?; - - Type::Option(Box::new(inner_type)) - } - _ => { - return Err(Error::UnexpectedSyntaxNode { - expected: "any, bool, float, function, int, list, map, num, str or option" - .to_string(), + _ => return Err(Error::UnexpectedSyntaxNode { + expected: + "any, bool, collection, float, function, int, list, map, num, str or option" + .to_string(), actual: type_node.kind().to_string(), location: type_node.start_position(), relevant_source: source[type_node.byte_range()].to_string(), - }) - } - }; + }), + }; Ok(r#type) } @@ -240,6 +249,7 @@ impl Display for Type { match self { Type::Any => write!(f, "any"), Type::Boolean => write!(f, "bool"), + Type::Collection => write!(f, "collection"), Type::Float => write!(f, "float"), Type::Function { parameter_types, diff --git a/src/built_in_functions/mod.rs b/src/built_in_functions/mod.rs index d7fa829..126efe2 100644 --- a/src/built_in_functions/mod.rs +++ b/src/built_in_functions/mod.rs @@ -34,9 +34,7 @@ impl BuiltInFunction { BuiltInFunction::FsRead => Type::function(vec![Type::String], Type::String), BuiltInFunction::Output => Type::function(vec![Type::Any], Type::None), BuiltInFunction::RandomBoolean => Type::function(vec![], Type::Boolean), - BuiltInFunction::Length => { - Type::function(vec![Type::list_of(Type::Any)], Type::Integer) - } + BuiltInFunction::Length => Type::function(vec![Type::Collection], Type::Integer), } } @@ -75,9 +73,20 @@ impl BuiltInFunction { BuiltInFunction::Length => { Error::expect_argument_amount(self, 1, arguments.len())?; - let list_len = arguments.first().unwrap().as_list()?.items().len() as i64; + let value = arguments.first().unwrap(); + let length = if let Ok(list) = value.as_list() { + list.items().len() + } else if let Ok(map) = value.as_map() { + map.variables()?.len() + } else if let Ok(string) = value.as_string() { + string.chars().count() + } else { + return Err(Error::ExpectedCollection { + actual: value.clone(), + }); + }; - Ok(Value::Integer(list_len)) + Ok(Value::Integer(length as i64)) } } } diff --git a/src/lib.rs b/src/lib.rs index 0568d84..b539bb6 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -12,7 +12,7 @@ pub use crate::{ function::{ContextDefinedFunction, Function}, list::List, map::Map, - BuiltInValue, Value, + Value, }, }; diff --git a/src/value/mod.rs b/src/value/mod.rs index 9cc3692..d077443 100644 --- a/src/value/mod.rs +++ b/src/value/mod.rs @@ -1,7 +1,7 @@ //! Types that represent runtime values. use crate::{ error::{Error, Result}, - AbstractTree, BuiltInFunction, Function, List, Map, Type, + Function, List, Map, Type, }; use serde::{ @@ -9,101 +9,19 @@ use serde::{ ser::SerializeTuple, Deserialize, Serialize, Serializer, }; -use tree_sitter::Node; use std::{ cmp::Ordering, convert::TryFrom, - env::args, fmt::{self, Display, Formatter}, marker::PhantomData, ops::{Add, AddAssign, Div, Mul, Rem, Sub, SubAssign}, - sync::OnceLock, }; pub mod function; pub mod list; pub mod map; -static ARGS: OnceLock = OnceLock::new(); -static RANDOM: OnceLock = OnceLock::new(); - -#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] -pub enum BuiltInValue { - Args, - AssertEqual, - Length, - Output, - Random, -} - -impl BuiltInValue { - fn r#type(&self) -> Type { - match self { - BuiltInValue::Args => Type::list_of(Type::String), - BuiltInValue::AssertEqual => BuiltInFunction::AssertEqual.r#type(), - BuiltInValue::Length => BuiltInFunction::Length.r#type(), - BuiltInValue::Output => BuiltInFunction::Output.r#type(), - BuiltInValue::Random => Type::Map, - } - } - - fn get(&self) -> &Value { - match self { - BuiltInValue::Args => ARGS.get_or_init(|| { - let args = args().map(|arg| Value::String(arg.to_string())).collect(); - - Value::List(List::with_items(args)) - }), - BuiltInValue::AssertEqual => { - &Value::Function(Function::BuiltIn(BuiltInFunction::AssertEqual)) - } - BuiltInValue::Length => &Value::Function(Function::BuiltIn(BuiltInFunction::Length)), - BuiltInValue::Output => &Value::Function(Function::BuiltIn(BuiltInFunction::Output)), - BuiltInValue::Random => RANDOM.get_or_init(|| { - let random_context = Map::new(); - - { - let mut variables = random_context.variables_mut().unwrap(); - - for built_in_function in [BuiltInFunction::RandomBoolean] { - let key = built_in_function.name().to_string(); - let value = Value::Function(Function::BuiltIn(built_in_function)); - let r#type = built_in_function.r#type(); - - variables.insert(key, (value, r#type)); - } - } - - Value::Map(random_context) - }), - } - } -} - -impl AbstractTree for BuiltInValue { - fn from_syntax_node(_source: &str, node: Node, _context: &Map) -> Result { - let built_in_value = match node.kind() { - "args" => BuiltInValue::Args, - "assert_equal" => BuiltInValue::AssertEqual, - "length" => BuiltInValue::Length, - "output" => BuiltInValue::Output, - "random" => BuiltInValue::Random, - _ => todo!(), - }; - - Ok(built_in_value) - } - - fn run(&self, _source: &str, _context: &Map) -> Result { - Ok(self.get().clone()) - } - - fn expected_type(&self, _context: &Map) -> Result { - Ok(self.r#type()) - } -} - /// Dust value representation. /// /// Every dust variable has a key and a Value. Variables are represented by diff --git a/tree-sitter-dust/grammar.js b/tree-sitter-dust/grammar.js index 558df6e..d91fa96 100644 --- a/tree-sitter-dust/grammar.js +++ b/tree-sitter-dust/grammar.js @@ -344,6 +344,7 @@ module.exports = grammar({ choice( 'any', 'bool', + 'collection', 'float', 'int', 'map', diff --git a/tree-sitter-dust/src/grammar.json b/tree-sitter-dust/src/grammar.json index 1106b16..994266e 100644 --- a/tree-sitter-dust/src/grammar.json +++ b/tree-sitter-dust/src/grammar.json @@ -1087,6 +1087,10 @@ "type": "STRING", "value": "bool" }, + { + "type": "STRING", + "value": "collection" + }, { "type": "STRING", "value": "float" diff --git a/tree-sitter-dust/src/node-types.json b/tree-sitter-dust/src/node-types.json index 1b77063..f000b88 100644 --- a/tree-sitter-dust/src/node-types.json +++ b/tree-sitter-dust/src/node-types.json @@ -772,6 +772,10 @@ "type": "bool", "named": false }, + { + "type": "collection", + "named": false + }, { "type": "else", "named": false diff --git a/tree-sitter-dust/src/parser.c b/tree-sitter-dust/src/parser.c index dd4f76f..71affa7 100644 --- a/tree-sitter-dust/src/parser.c +++ b/tree-sitter-dust/src/parser.c @@ -8,9 +8,9 @@ #define LANGUAGE_VERSION 14 #define STATE_COUNT 446 #define LARGE_STATE_COUNT 27 -#define SYMBOL_COUNT 105 +#define SYMBOL_COUNT 106 #define ALIAS_COUNT 0 -#define TOKEN_COUNT 62 +#define TOKEN_COUNT 63 #define EXTERNAL_TOKEN_COUNT 0 #define FIELD_COUNT 0 #define MAX_ALIAS_SEQUENCE_LENGTH 6 @@ -65,62 +65,63 @@ enum { anon_sym_return = 46, anon_sym_any = 47, anon_sym_bool = 48, - anon_sym_float = 49, - anon_sym_int = 50, - anon_sym_map = 51, - anon_sym_num = 52, - anon_sym_str = 53, - anon_sym_DASH_GT = 54, - anon_sym_option = 55, - anon_sym_args = 56, - anon_sym_assert_equal = 57, - anon_sym_env = 58, - anon_sym_length = 59, - anon_sym_output = 60, - anon_sym_random = 61, - sym_root = 62, - sym_statement = 63, - sym_expression = 64, - sym__expression_kind = 65, - aux_sym__expression_list = 66, - sym_block = 67, - sym_value = 68, - sym_boolean = 69, - sym_list = 70, - sym_map = 71, - sym_option = 72, - sym_index = 73, - sym_index_expression = 74, - sym_math = 75, - sym_math_operator = 76, - sym_logic = 77, - sym_logic_operator = 78, - sym_assignment = 79, - sym_index_assignment = 80, - sym_assignment_operator = 81, - sym_if_else = 82, - sym_if = 83, - sym_else_if = 84, - sym_else = 85, - sym_match = 86, - sym_while = 87, - sym_for = 88, - sym_return = 89, - sym_type_definition = 90, - sym_type = 91, - sym_function = 92, - sym_function_expression = 93, - sym__function_expression_kind = 94, - sym_function_call = 95, - sym_yield = 96, - sym_built_in_value = 97, - aux_sym_root_repeat1 = 98, - aux_sym_list_repeat1 = 99, - aux_sym_map_repeat1 = 100, - aux_sym_if_else_repeat1 = 101, - aux_sym_match_repeat1 = 102, - aux_sym_type_repeat1 = 103, - aux_sym_function_repeat1 = 104, + anon_sym_collection = 49, + anon_sym_float = 50, + anon_sym_int = 51, + anon_sym_map = 52, + anon_sym_num = 53, + anon_sym_str = 54, + anon_sym_DASH_GT = 55, + anon_sym_option = 56, + anon_sym_args = 57, + anon_sym_assert_equal = 58, + anon_sym_env = 59, + anon_sym_length = 60, + anon_sym_output = 61, + anon_sym_random = 62, + sym_root = 63, + sym_statement = 64, + sym_expression = 65, + sym__expression_kind = 66, + aux_sym__expression_list = 67, + sym_block = 68, + sym_value = 69, + sym_boolean = 70, + sym_list = 71, + sym_map = 72, + sym_option = 73, + sym_index = 74, + sym_index_expression = 75, + sym_math = 76, + sym_math_operator = 77, + sym_logic = 78, + sym_logic_operator = 79, + sym_assignment = 80, + sym_index_assignment = 81, + sym_assignment_operator = 82, + sym_if_else = 83, + sym_if = 84, + sym_else_if = 85, + sym_else = 86, + sym_match = 87, + sym_while = 88, + sym_for = 89, + sym_return = 90, + sym_type_definition = 91, + sym_type = 92, + sym_function = 93, + sym_function_expression = 94, + sym__function_expression_kind = 95, + sym_function_call = 96, + sym_yield = 97, + sym_built_in_value = 98, + aux_sym_root_repeat1 = 99, + aux_sym_list_repeat1 = 100, + aux_sym_map_repeat1 = 101, + aux_sym_if_else_repeat1 = 102, + aux_sym_match_repeat1 = 103, + aux_sym_type_repeat1 = 104, + aux_sym_function_repeat1 = 105, }; static const char * const ts_symbol_names[] = { @@ -173,6 +174,7 @@ static const char * const ts_symbol_names[] = { [anon_sym_return] = "return", [anon_sym_any] = "any", [anon_sym_bool] = "bool", + [anon_sym_collection] = "collection", [anon_sym_float] = "float", [anon_sym_int] = "int", [anon_sym_map] = "map", @@ -281,6 +283,7 @@ static const TSSymbol ts_symbol_map[] = { [anon_sym_return] = anon_sym_return, [anon_sym_any] = anon_sym_any, [anon_sym_bool] = anon_sym_bool, + [anon_sym_collection] = anon_sym_collection, [anon_sym_float] = anon_sym_float, [anon_sym_int] = anon_sym_int, [anon_sym_map] = anon_sym_map, @@ -536,6 +539,10 @@ static const TSSymbolMetadata ts_symbol_metadata[] = { .visible = true, .named = false, }, + [anon_sym_collection] = { + .visible = true, + .named = false, + }, [anon_sym_float] = { .visible = true, .named = false, @@ -1098,42 +1105,42 @@ static const TSStateId ts_primary_state_ids[STATE_COUNT] = { [324] = 52, [325] = 58, [326] = 326, - [327] = 45, + [327] = 327, [328] = 328, [329] = 328, [330] = 330, - [331] = 326, - [332] = 326, - [333] = 46, - [334] = 334, + [331] = 331, + [332] = 332, + [333] = 332, + [334] = 332, [335] = 335, - [336] = 336, - [337] = 336, - [338] = 336, - [339] = 336, - [340] = 336, - [341] = 336, - [342] = 336, + [336] = 45, + [337] = 46, + [338] = 338, + [339] = 338, + [340] = 338, + [341] = 341, + [342] = 338, [343] = 343, - [344] = 336, - [345] = 336, - [346] = 343, - [347] = 347, - [348] = 348, + [344] = 344, + [345] = 338, + [346] = 346, + [347] = 338, + [348] = 338, [349] = 343, - [350] = 336, - [351] = 336, - [352] = 336, + [350] = 338, + [351] = 338, + [352] = 338, [353] = 343, - [354] = 354, - [355] = 354, + [354] = 338, + [355] = 338, [356] = 356, - [357] = 354, + [357] = 343, [358] = 358, - [359] = 359, + [359] = 358, [360] = 360, [361] = 361, - [362] = 362, + [362] = 358, [363] = 363, [364] = 364, [365] = 365, @@ -1745,333 +1752,364 @@ static bool ts_lex_keywords(TSLexer *lexer, TSStateId state) { case 0: if (lookahead == 'a') ADVANCE(1); if (lookahead == 'b') ADVANCE(2); - if (lookahead == 'e') ADVANCE(3); - if (lookahead == 'f') ADVANCE(4); - if (lookahead == 'i') ADVANCE(5); - if (lookahead == 'l') ADVANCE(6); - if (lookahead == 'm') ADVANCE(7); - if (lookahead == 'n') ADVANCE(8); - if (lookahead == 'o') ADVANCE(9); - if (lookahead == 'r') ADVANCE(10); - if (lookahead == 's') ADVANCE(11); - if (lookahead == 't') ADVANCE(12); - if (lookahead == 'w') ADVANCE(13); + if (lookahead == 'c') ADVANCE(3); + if (lookahead == 'e') ADVANCE(4); + if (lookahead == 'f') ADVANCE(5); + if (lookahead == 'i') ADVANCE(6); + if (lookahead == 'l') ADVANCE(7); + if (lookahead == 'm') ADVANCE(8); + if (lookahead == 'n') ADVANCE(9); + if (lookahead == 'o') ADVANCE(10); + if (lookahead == 'r') ADVANCE(11); + if (lookahead == 's') ADVANCE(12); + if (lookahead == 't') ADVANCE(13); + if (lookahead == 'w') ADVANCE(14); if (lookahead == '\t' || lookahead == '\n' || lookahead == '\r' || lookahead == ' ') SKIP(0) END_STATE(); case 1: - if (lookahead == 'n') ADVANCE(14); - if (lookahead == 'r') ADVANCE(15); - if (lookahead == 's') ADVANCE(16); + if (lookahead == 'n') ADVANCE(15); + if (lookahead == 'r') ADVANCE(16); + if (lookahead == 's') ADVANCE(17); END_STATE(); case 2: - if (lookahead == 'o') ADVANCE(17); + if (lookahead == 'o') ADVANCE(18); END_STATE(); case 3: - if (lookahead == 'l') ADVANCE(18); - if (lookahead == 'n') ADVANCE(19); + if (lookahead == 'o') ADVANCE(19); END_STATE(); case 4: - if (lookahead == 'a') ADVANCE(20); - if (lookahead == 'l') ADVANCE(21); - if (lookahead == 'o') ADVANCE(22); + if (lookahead == 'l') ADVANCE(20); + if (lookahead == 'n') ADVANCE(21); END_STATE(); case 5: - if (lookahead == 'f') ADVANCE(23); - if (lookahead == 'n') ADVANCE(24); + if (lookahead == 'a') ADVANCE(22); + if (lookahead == 'l') ADVANCE(23); + if (lookahead == 'o') ADVANCE(24); END_STATE(); case 6: - if (lookahead == 'e') ADVANCE(25); + if (lookahead == 'f') ADVANCE(25); + if (lookahead == 'n') ADVANCE(26); END_STATE(); case 7: - if (lookahead == 'a') ADVANCE(26); + if (lookahead == 'e') ADVANCE(27); END_STATE(); case 8: - if (lookahead == 'o') ADVANCE(27); - if (lookahead == 'u') ADVANCE(28); + if (lookahead == 'a') ADVANCE(28); END_STATE(); case 9: - if (lookahead == 'p') ADVANCE(29); + if (lookahead == 'o') ADVANCE(29); if (lookahead == 'u') ADVANCE(30); END_STATE(); case 10: - if (lookahead == 'a') ADVANCE(31); - if (lookahead == 'e') ADVANCE(32); + if (lookahead == 'p') ADVANCE(31); + if (lookahead == 'u') ADVANCE(32); END_STATE(); case 11: - if (lookahead == 'o') ADVANCE(33); - if (lookahead == 't') ADVANCE(34); + if (lookahead == 'a') ADVANCE(33); + if (lookahead == 'e') ADVANCE(34); END_STATE(); case 12: - if (lookahead == 'r') ADVANCE(35); + if (lookahead == 'o') ADVANCE(35); + if (lookahead == 't') ADVANCE(36); END_STATE(); case 13: - if (lookahead == 'h') ADVANCE(36); + if (lookahead == 'r') ADVANCE(37); END_STATE(); case 14: - if (lookahead == 'y') ADVANCE(37); + if (lookahead == 'h') ADVANCE(38); END_STATE(); case 15: - if (lookahead == 'g') ADVANCE(38); + if (lookahead == 'y') ADVANCE(39); END_STATE(); case 16: - if (lookahead == 's') ADVANCE(39); - if (lookahead == 'y') ADVANCE(40); + if (lookahead == 'g') ADVANCE(40); END_STATE(); case 17: - if (lookahead == 'o') ADVANCE(41); + if (lookahead == 's') ADVANCE(41); + if (lookahead == 'y') ADVANCE(42); END_STATE(); case 18: - if (lookahead == 's') ADVANCE(42); + if (lookahead == 'o') ADVANCE(43); END_STATE(); case 19: - if (lookahead == 'v') ADVANCE(43); - END_STATE(); - case 20: if (lookahead == 'l') ADVANCE(44); END_STATE(); + case 20: + if (lookahead == 's') ADVANCE(45); + END_STATE(); case 21: - if (lookahead == 'o') ADVANCE(45); + if (lookahead == 'v') ADVANCE(46); END_STATE(); case 22: - if (lookahead == 'r') ADVANCE(46); + if (lookahead == 'l') ADVANCE(47); END_STATE(); case 23: - ACCEPT_TOKEN(anon_sym_if); + if (lookahead == 'o') ADVANCE(48); END_STATE(); case 24: - ACCEPT_TOKEN(anon_sym_in); - if (lookahead == 't') ADVANCE(47); + if (lookahead == 'r') ADVANCE(49); END_STATE(); case 25: - if (lookahead == 'n') ADVANCE(48); + ACCEPT_TOKEN(anon_sym_if); END_STATE(); case 26: - if (lookahead == 'p') ADVANCE(49); + ACCEPT_TOKEN(anon_sym_in); if (lookahead == 't') ADVANCE(50); END_STATE(); case 27: if (lookahead == 'n') ADVANCE(51); END_STATE(); case 28: - if (lookahead == 'm') ADVANCE(52); - END_STATE(); - case 29: + if (lookahead == 'p') ADVANCE(52); if (lookahead == 't') ADVANCE(53); END_STATE(); + case 29: + if (lookahead == 'n') ADVANCE(54); + END_STATE(); case 30: - if (lookahead == 't') ADVANCE(54); + if (lookahead == 'm') ADVANCE(55); END_STATE(); case 31: - if (lookahead == 'n') ADVANCE(55); - END_STATE(); - case 32: if (lookahead == 't') ADVANCE(56); END_STATE(); + case 32: + if (lookahead == 't') ADVANCE(57); + END_STATE(); case 33: - if (lookahead == 'm') ADVANCE(57); + if (lookahead == 'n') ADVANCE(58); END_STATE(); case 34: - if (lookahead == 'r') ADVANCE(58); + if (lookahead == 't') ADVANCE(59); END_STATE(); case 35: - if (lookahead == 'u') ADVANCE(59); + if (lookahead == 'm') ADVANCE(60); END_STATE(); case 36: - if (lookahead == 'i') ADVANCE(60); + if (lookahead == 'r') ADVANCE(61); END_STATE(); case 37: - ACCEPT_TOKEN(anon_sym_any); + if (lookahead == 'u') ADVANCE(62); END_STATE(); case 38: - if (lookahead == 's') ADVANCE(61); + if (lookahead == 'i') ADVANCE(63); END_STATE(); case 39: - if (lookahead == 'e') ADVANCE(62); + ACCEPT_TOKEN(anon_sym_any); END_STATE(); case 40: - if (lookahead == 'n') ADVANCE(63); + if (lookahead == 's') ADVANCE(64); END_STATE(); case 41: - if (lookahead == 'l') ADVANCE(64); - END_STATE(); - case 42: if (lookahead == 'e') ADVANCE(65); END_STATE(); + case 42: + if (lookahead == 'n') ADVANCE(66); + END_STATE(); case 43: - ACCEPT_TOKEN(anon_sym_env); + if (lookahead == 'l') ADVANCE(67); END_STATE(); case 44: - if (lookahead == 's') ADVANCE(66); + if (lookahead == 'l') ADVANCE(68); END_STATE(); case 45: - if (lookahead == 'a') ADVANCE(67); + if (lookahead == 'e') ADVANCE(69); END_STATE(); case 46: - ACCEPT_TOKEN(anon_sym_for); + ACCEPT_TOKEN(anon_sym_env); END_STATE(); case 47: - ACCEPT_TOKEN(anon_sym_int); + if (lookahead == 's') ADVANCE(70); END_STATE(); case 48: - if (lookahead == 'g') ADVANCE(68); + if (lookahead == 'a') ADVANCE(71); END_STATE(); case 49: - ACCEPT_TOKEN(anon_sym_map); + ACCEPT_TOKEN(anon_sym_for); END_STATE(); case 50: - if (lookahead == 'c') ADVANCE(69); + ACCEPT_TOKEN(anon_sym_int); END_STATE(); case 51: - if (lookahead == 'e') ADVANCE(70); + if (lookahead == 'g') ADVANCE(72); END_STATE(); case 52: - ACCEPT_TOKEN(anon_sym_num); + ACCEPT_TOKEN(anon_sym_map); END_STATE(); case 53: - if (lookahead == 'i') ADVANCE(71); + if (lookahead == 'c') ADVANCE(73); END_STATE(); case 54: - if (lookahead == 'p') ADVANCE(72); + if (lookahead == 'e') ADVANCE(74); END_STATE(); case 55: - if (lookahead == 'd') ADVANCE(73); + ACCEPT_TOKEN(anon_sym_num); END_STATE(); case 56: - if (lookahead == 'u') ADVANCE(74); + if (lookahead == 'i') ADVANCE(75); END_STATE(); case 57: - if (lookahead == 'e') ADVANCE(75); + if (lookahead == 'p') ADVANCE(76); END_STATE(); case 58: - ACCEPT_TOKEN(anon_sym_str); + if (lookahead == 'd') ADVANCE(77); END_STATE(); case 59: - if (lookahead == 'e') ADVANCE(76); + if (lookahead == 'u') ADVANCE(78); END_STATE(); case 60: - if (lookahead == 'l') ADVANCE(77); + if (lookahead == 'e') ADVANCE(79); END_STATE(); case 61: - ACCEPT_TOKEN(anon_sym_args); + ACCEPT_TOKEN(anon_sym_str); END_STATE(); case 62: - if (lookahead == 'r') ADVANCE(78); - END_STATE(); - case 63: - if (lookahead == 'c') ADVANCE(79); - END_STATE(); - case 64: - ACCEPT_TOKEN(anon_sym_bool); - END_STATE(); - case 65: - ACCEPT_TOKEN(anon_sym_else); - END_STATE(); - case 66: if (lookahead == 'e') ADVANCE(80); END_STATE(); + case 63: + if (lookahead == 'l') ADVANCE(81); + END_STATE(); + case 64: + ACCEPT_TOKEN(anon_sym_args); + END_STATE(); + case 65: + if (lookahead == 'r') ADVANCE(82); + END_STATE(); + case 66: + if (lookahead == 'c') ADVANCE(83); + END_STATE(); case 67: - if (lookahead == 't') ADVANCE(81); + ACCEPT_TOKEN(anon_sym_bool); END_STATE(); case 68: - if (lookahead == 't') ADVANCE(82); + if (lookahead == 'e') ADVANCE(84); END_STATE(); case 69: - if (lookahead == 'h') ADVANCE(83); + ACCEPT_TOKEN(anon_sym_else); END_STATE(); case 70: - ACCEPT_TOKEN(anon_sym_none); + if (lookahead == 'e') ADVANCE(85); END_STATE(); case 71: - if (lookahead == 'o') ADVANCE(84); + if (lookahead == 't') ADVANCE(86); END_STATE(); case 72: - if (lookahead == 'u') ADVANCE(85); + if (lookahead == 't') ADVANCE(87); END_STATE(); case 73: - if (lookahead == 'o') ADVANCE(86); + if (lookahead == 'h') ADVANCE(88); END_STATE(); case 74: - if (lookahead == 'r') ADVANCE(87); + ACCEPT_TOKEN(anon_sym_none); END_STATE(); case 75: - ACCEPT_TOKEN(anon_sym_some); + if (lookahead == 'o') ADVANCE(89); END_STATE(); case 76: - ACCEPT_TOKEN(anon_sym_true); + if (lookahead == 'u') ADVANCE(90); END_STATE(); case 77: - if (lookahead == 'e') ADVANCE(88); + if (lookahead == 'o') ADVANCE(91); END_STATE(); case 78: - if (lookahead == 't') ADVANCE(89); + if (lookahead == 'r') ADVANCE(92); END_STATE(); case 79: - ACCEPT_TOKEN(anon_sym_async); + ACCEPT_TOKEN(anon_sym_some); END_STATE(); case 80: - ACCEPT_TOKEN(anon_sym_false); + ACCEPT_TOKEN(anon_sym_true); END_STATE(); case 81: - ACCEPT_TOKEN(anon_sym_float); + if (lookahead == 'e') ADVANCE(93); END_STATE(); case 82: - if (lookahead == 'h') ADVANCE(90); + if (lookahead == 't') ADVANCE(94); END_STATE(); case 83: - ACCEPT_TOKEN(anon_sym_match); + ACCEPT_TOKEN(anon_sym_async); END_STATE(); case 84: - if (lookahead == 'n') ADVANCE(91); + if (lookahead == 'c') ADVANCE(95); END_STATE(); case 85: - if (lookahead == 't') ADVANCE(92); + ACCEPT_TOKEN(anon_sym_false); END_STATE(); case 86: - if (lookahead == 'm') ADVANCE(93); + ACCEPT_TOKEN(anon_sym_float); END_STATE(); case 87: - if (lookahead == 'n') ADVANCE(94); + if (lookahead == 'h') ADVANCE(96); END_STATE(); case 88: - ACCEPT_TOKEN(anon_sym_while); + ACCEPT_TOKEN(anon_sym_match); END_STATE(); case 89: - if (lookahead == '_') ADVANCE(95); + if (lookahead == 'n') ADVANCE(97); END_STATE(); case 90: - ACCEPT_TOKEN(anon_sym_length); + if (lookahead == 't') ADVANCE(98); END_STATE(); case 91: - ACCEPT_TOKEN(anon_sym_option); + if (lookahead == 'm') ADVANCE(99); END_STATE(); case 92: - ACCEPT_TOKEN(anon_sym_output); + if (lookahead == 'n') ADVANCE(100); END_STATE(); case 93: - ACCEPT_TOKEN(anon_sym_random); + ACCEPT_TOKEN(anon_sym_while); END_STATE(); case 94: - ACCEPT_TOKEN(anon_sym_return); + if (lookahead == '_') ADVANCE(101); END_STATE(); case 95: - if (lookahead == 'e') ADVANCE(96); + if (lookahead == 't') ADVANCE(102); END_STATE(); case 96: - if (lookahead == 'q') ADVANCE(97); + ACCEPT_TOKEN(anon_sym_length); END_STATE(); case 97: - if (lookahead == 'u') ADVANCE(98); + ACCEPT_TOKEN(anon_sym_option); END_STATE(); case 98: - if (lookahead == 'a') ADVANCE(99); + ACCEPT_TOKEN(anon_sym_output); END_STATE(); case 99: - if (lookahead == 'l') ADVANCE(100); + ACCEPT_TOKEN(anon_sym_random); END_STATE(); case 100: + ACCEPT_TOKEN(anon_sym_return); + END_STATE(); + case 101: + if (lookahead == 'e') ADVANCE(103); + END_STATE(); + case 102: + if (lookahead == 'i') ADVANCE(104); + END_STATE(); + case 103: + if (lookahead == 'q') ADVANCE(105); + END_STATE(); + case 104: + if (lookahead == 'o') ADVANCE(106); + END_STATE(); + case 105: + if (lookahead == 'u') ADVANCE(107); + END_STATE(); + case 106: + if (lookahead == 'n') ADVANCE(108); + END_STATE(); + case 107: + if (lookahead == 'a') ADVANCE(109); + END_STATE(); + case 108: + ACCEPT_TOKEN(anon_sym_collection); + END_STATE(); + case 109: + if (lookahead == 'l') ADVANCE(110); + END_STATE(); + case 110: ACCEPT_TOKEN(anon_sym_assert_equal); END_STATE(); default: @@ -2406,29 +2444,29 @@ static const TSLexMode ts_lex_modes[STATE_COUNT] = { [323] = {.lex_state = 1}, [324] = {.lex_state = 2}, [325] = {.lex_state = 2}, - [326] = {.lex_state = 2}, - [327] = {.lex_state = 2}, + [326] = {.lex_state = 7}, + [327] = {.lex_state = 3}, [328] = {.lex_state = 2}, [329] = {.lex_state = 2}, [330] = {.lex_state = 1}, - [331] = {.lex_state = 2}, + [331] = {.lex_state = 7}, [332] = {.lex_state = 2}, [333] = {.lex_state = 2}, - [334] = {.lex_state = 3}, + [334] = {.lex_state = 2}, [335] = {.lex_state = 1}, [336] = {.lex_state = 2}, [337] = {.lex_state = 2}, [338] = {.lex_state = 2}, [339] = {.lex_state = 2}, [340] = {.lex_state = 2}, - [341] = {.lex_state = 2}, + [341] = {.lex_state = 7}, [342] = {.lex_state = 2}, [343] = {.lex_state = 2}, - [344] = {.lex_state = 2}, + [344] = {.lex_state = 7}, [345] = {.lex_state = 2}, - [346] = {.lex_state = 2}, - [347] = {.lex_state = 7}, - [348] = {.lex_state = 7}, + [346] = {.lex_state = 7}, + [347] = {.lex_state = 2}, + [348] = {.lex_state = 2}, [349] = {.lex_state = 2}, [350] = {.lex_state = 2}, [351] = {.lex_state = 2}, @@ -2438,11 +2476,11 @@ static const TSLexMode ts_lex_modes[STATE_COUNT] = { [355] = {.lex_state = 2}, [356] = {.lex_state = 7}, [357] = {.lex_state = 2}, - [358] = {.lex_state = 7}, - [359] = {.lex_state = 7}, - [360] = {.lex_state = 7}, + [358] = {.lex_state = 2}, + [359] = {.lex_state = 2}, + [360] = {.lex_state = 1}, [361] = {.lex_state = 1}, - [362] = {.lex_state = 1}, + [362] = {.lex_state = 2}, [363] = {.lex_state = 1}, [364] = {.lex_state = 1}, [365] = {.lex_state = 1}, @@ -2579,6 +2617,7 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_return] = ACTIONS(1), [anon_sym_any] = ACTIONS(1), [anon_sym_bool] = ACTIONS(1), + [anon_sym_collection] = ACTIONS(1), [anon_sym_float] = ACTIONS(1), [anon_sym_int] = ACTIONS(1), [anon_sym_map] = ACTIONS(1), @@ -9378,7 +9417,7 @@ static const uint16_t ts_small_parse_table[] = { sym__function_expression_kind, STATE(124), 1, aux_sym_match_repeat1, - STATE(334), 1, + STATE(327), 1, sym_expression, STATE(439), 1, sym_function_expression, @@ -9439,7 +9478,7 @@ static const uint16_t ts_small_parse_table[] = { sym__function_expression_kind, STATE(124), 1, aux_sym_match_repeat1, - STATE(334), 1, + STATE(327), 1, sym_expression, STATE(439), 1, sym_function_expression, @@ -9500,7 +9539,7 @@ static const uint16_t ts_small_parse_table[] = { sym__function_expression_kind, STATE(124), 1, aux_sym_match_repeat1, - STATE(334), 1, + STATE(327), 1, sym_expression, STATE(439), 1, sym_function_expression, @@ -9886,7 +9925,7 @@ static const uint16_t ts_small_parse_table[] = { sym__function_expression_kind, STATE(122), 1, aux_sym_match_repeat1, - STATE(334), 1, + STATE(327), 1, sym_expression, STATE(439), 1, sym_function_expression, @@ -10013,7 +10052,7 @@ static const uint16_t ts_small_parse_table[] = { STATE(237), 2, sym_value, sym_index, - STATE(357), 3, + STATE(359), 3, sym__expression_kind, sym_math, sym_logic, @@ -10073,7 +10112,7 @@ static const uint16_t ts_small_parse_table[] = { STATE(237), 2, sym_value, sym_index, - STATE(357), 3, + STATE(359), 3, sym__expression_kind, sym_math, sym_logic, @@ -10133,7 +10172,7 @@ static const uint16_t ts_small_parse_table[] = { STATE(237), 2, sym_value, sym_index, - STATE(357), 3, + STATE(359), 3, sym__expression_kind, sym_math, sym_logic, @@ -10193,7 +10232,7 @@ static const uint16_t ts_small_parse_table[] = { STATE(237), 2, sym_value, sym_index, - STATE(357), 3, + STATE(359), 3, sym__expression_kind, sym_math, sym_logic, @@ -10234,7 +10273,7 @@ static const uint16_t ts_small_parse_table[] = { sym__function_expression_kind, STATE(123), 1, aux_sym_match_repeat1, - STATE(334), 1, + STATE(327), 1, sym_expression, STATE(439), 1, sym_function_expression, @@ -10548,7 +10587,7 @@ static const uint16_t ts_small_parse_table[] = { STATE(237), 2, sym_value, sym_index, - STATE(355), 3, + STATE(358), 3, sym__expression_kind, sym_math, sym_logic, @@ -10707,9 +10746,9 @@ static const uint16_t ts_small_parse_table[] = { sym__function_expression_kind, STATE(241), 1, sym_yield, - STATE(336), 1, + STATE(338), 1, sym_expression, - STATE(346), 1, + STATE(357), 1, sym_function_call, STATE(391), 1, aux_sym_function_repeat1, @@ -10963,7 +11002,7 @@ static const uint16_t ts_small_parse_table[] = { STATE(237), 2, sym_value, sym_index, - STATE(354), 3, + STATE(362), 3, sym__expression_kind, sym_math, sym_logic, @@ -11004,7 +11043,7 @@ static const uint16_t ts_small_parse_table[] = { sym__function_expression_kind, STATE(241), 1, sym_yield, - STATE(336), 1, + STATE(338), 1, sym_expression, STATE(353), 1, sym_function_call, @@ -11064,7 +11103,7 @@ static const uint16_t ts_small_parse_table[] = { sym__function_expression_kind, STATE(241), 1, sym_yield, - STATE(336), 1, + STATE(338), 1, sym_expression, STATE(343), 1, sym_function_call, @@ -11507,7 +11546,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LPAREN, STATE(243), 1, sym_function_expression, - STATE(351), 1, + STATE(350), 1, sym_expression, STATE(420), 1, sym_index_expression, @@ -11616,7 +11655,7 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, STATE(243), 1, sym_function_expression, - STATE(339), 1, + STATE(345), 1, sym_expression, STATE(442), 1, sym_index_expression, @@ -11834,7 +11873,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LPAREN, STATE(105), 1, sym_function_expression, - STATE(345), 1, + STATE(355), 1, sym_expression, STATE(415), 1, sym_index_expression, @@ -12162,7 +12201,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LPAREN, STATE(243), 1, sym_function_expression, - STATE(336), 1, + STATE(338), 1, sym_expression, STATE(442), 1, sym_index_expression, @@ -12656,7 +12695,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LPAREN, STATE(79), 1, sym_function_expression, - STATE(341), 1, + STATE(347), 1, sym_expression, STATE(438), 1, sym_index_expression, @@ -12819,7 +12858,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LPAREN, STATE(105), 1, sym_function_expression, - STATE(350), 1, + STATE(348), 1, sym_expression, STATE(435), 1, sym_index_expression, @@ -12982,7 +13021,7 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, STATE(59), 1, sym__function_expression_kind, - STATE(327), 1, + STATE(336), 1, sym_expression, STATE(420), 1, sym_index_expression, @@ -13037,7 +13076,7 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, STATE(59), 1, sym__function_expression_kind, - STATE(333), 1, + STATE(337), 1, sym_expression, STATE(420), 1, sym_index_expression, @@ -13422,7 +13461,7 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, STATE(59), 1, sym__function_expression_kind, - STATE(332), 1, + STATE(334), 1, sym_expression, STATE(420), 1, sym_index_expression, @@ -13477,7 +13516,7 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, STATE(243), 1, sym_function_expression, - STATE(338), 1, + STATE(342), 1, sym_expression, STATE(423), 1, sym_index_expression, @@ -13530,7 +13569,7 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, STATE(59), 1, sym__function_expression_kind, - STATE(326), 1, + STATE(332), 1, sym_expression, STATE(420), 1, sym_index_expression, @@ -13640,7 +13679,7 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, STATE(59), 1, sym__function_expression_kind, - STATE(331), 1, + STATE(333), 1, sym_expression, STATE(420), 1, sym_index_expression, @@ -13915,7 +13954,7 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, STATE(243), 1, sym_function_expression, - STATE(342), 1, + STATE(351), 1, sym_expression, STATE(420), 1, sym_index_expression, @@ -14023,7 +14062,7 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, STATE(105), 1, sym_function_expression, - STATE(337), 1, + STATE(354), 1, sym_expression, STATE(435), 1, sym_index_expression, @@ -14077,7 +14116,7 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, STATE(79), 1, sym_function_expression, - STATE(344), 1, + STATE(339), 1, sym_expression, STATE(438), 1, sym_index_expression, @@ -18012,60 +18051,29 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_GT_EQ, anon_sym_LT_EQ, anon_sym_DASH_GT, - [17115] = 9, - ACTIONS(3), 1, - sym__comment, - ACTIONS(326), 1, - anon_sym_DASH, - ACTIONS(669), 1, - anon_sym_RPAREN, - ACTIONS(671), 1, - anon_sym_DASH_GT, - STATE(186), 1, - sym_math_operator, - STATE(187), 1, - sym_logic_operator, - ACTIONS(330), 2, - anon_sym_GT, - anon_sym_LT, - ACTIONS(324), 4, - anon_sym_PLUS, - anon_sym_STAR, - anon_sym_SLASH, - anon_sym_PERCENT, - ACTIONS(328), 6, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_AMP_AMP, - anon_sym_PIPE_PIPE, - anon_sym_GT_EQ, - anon_sym_LT_EQ, - [17152] = 6, + [17115] = 3, ACTIONS(3), 1, sym__comment, ACTIONS(671), 1, anon_sym_DASH_GT, - STATE(186), 1, - sym_math_operator, - STATE(187), 1, - sym_logic_operator, - ACTIONS(196), 3, - anon_sym_DASH, - anon_sym_GT, - anon_sym_LT, - ACTIONS(194), 11, + ACTIONS(669), 16, + anon_sym_LPAREN, anon_sym_RPAREN, - anon_sym_PLUS, - anon_sym_STAR, - anon_sym_SLASH, - anon_sym_PERCENT, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_AMP_AMP, - anon_sym_PIPE_PIPE, - anon_sym_GT_EQ, - anon_sym_LT_EQ, - [17183] = 9, + anon_sym_COMMA, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_none, + anon_sym_GT, + anon_sym_any, + anon_sym_bool, + anon_sym_collection, + anon_sym_float, + anon_sym_int, + anon_sym_map, + anon_sym_num, + anon_sym_str, + anon_sym_option, + [17140] = 9, ACTIONS(3), 1, sym__comment, ACTIONS(326), 1, @@ -18073,7 +18081,7 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(629), 1, anon_sym_DASH_GT, ACTIONS(673), 1, - anon_sym_LBRACE, + anon_sym_EQ_GT, STATE(173), 1, sym_logic_operator, STATE(174), 1, @@ -18093,7 +18101,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_GT_EQ, anon_sym_LT_EQ, - [17220] = 9, + [17177] = 9, ACTIONS(3), 1, sym__comment, ACTIONS(326), 1, @@ -18121,16 +18129,44 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_GT_EQ, anon_sym_LT_EQ, - [17257] = 3, + [17214] = 9, ACTIONS(3), 1, sym__comment, - ACTIONS(679), 5, + ACTIONS(326), 1, + anon_sym_DASH, + ACTIONS(629), 1, + anon_sym_DASH_GT, + ACTIONS(677), 1, + anon_sym_LBRACE, + STATE(173), 1, + sym_logic_operator, + STATE(174), 1, + sym_math_operator, + ACTIONS(330), 2, + anon_sym_GT, + anon_sym_LT, + ACTIONS(324), 4, + anon_sym_PLUS, + anon_sym_STAR, + anon_sym_SLASH, + anon_sym_PERCENT, + ACTIONS(328), 6, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + [17251] = 3, + ACTIONS(3), 1, + sym__comment, + ACTIONS(681), 5, anon_sym_LPAREN, anon_sym_LBRACE, sym_float, sym_string, anon_sym_LBRACK, - ACTIONS(677), 12, + ACTIONS(679), 12, sym_identifier, sym_integer, anon_sym_true, @@ -18143,14 +18179,64 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_length, anon_sym_output, anon_sym_random, - [17282] = 9, + [17276] = 3, + ACTIONS(3), 1, + sym__comment, + ACTIONS(685), 1, + anon_sym_DASH_GT, + ACTIONS(683), 16, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_COMMA, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_none, + anon_sym_GT, + anon_sym_any, + anon_sym_bool, + anon_sym_collection, + anon_sym_float, + anon_sym_int, + anon_sym_map, + anon_sym_num, + anon_sym_str, + anon_sym_option, + [17301] = 9, ACTIONS(3), 1, sym__comment, ACTIONS(326), 1, anon_sym_DASH, - ACTIONS(671), 1, + ACTIONS(687), 1, + anon_sym_RPAREN, + ACTIONS(689), 1, anon_sym_DASH_GT, - ACTIONS(681), 1, + STATE(186), 1, + sym_math_operator, + STATE(187), 1, + sym_logic_operator, + ACTIONS(330), 2, + anon_sym_GT, + anon_sym_LT, + ACTIONS(324), 4, + anon_sym_PLUS, + anon_sym_STAR, + anon_sym_SLASH, + anon_sym_PERCENT, + ACTIONS(328), 6, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + [17338] = 9, + ACTIONS(3), 1, + sym__comment, + ACTIONS(326), 1, + anon_sym_DASH, + ACTIONS(689), 1, + anon_sym_DASH_GT, + ACTIONS(691), 1, anon_sym_RPAREN, STATE(186), 1, sym_math_operator, @@ -18171,14 +18257,14 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_GT_EQ, anon_sym_LT_EQ, - [17319] = 9, + [17375] = 9, ACTIONS(3), 1, sym__comment, ACTIONS(326), 1, anon_sym_DASH, - ACTIONS(671), 1, + ACTIONS(689), 1, anon_sym_DASH_GT, - ACTIONS(683), 1, + ACTIONS(693), 1, anon_sym_RPAREN, STATE(186), 1, sym_math_operator, @@ -18199,10 +18285,57 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_GT_EQ, anon_sym_LT_EQ, - [17356] = 6, + [17412] = 3, ACTIONS(3), 1, sym__comment, - ACTIONS(671), 1, + ACTIONS(697), 5, + anon_sym_LPAREN, + anon_sym_LBRACE, + sym_float, + sym_string, + anon_sym_LBRACK, + ACTIONS(695), 12, + sym_identifier, + sym_integer, + anon_sym_true, + anon_sym_false, + anon_sym_none, + anon_sym_some, + anon_sym_args, + anon_sym_assert_equal, + anon_sym_env, + anon_sym_length, + anon_sym_output, + anon_sym_random, + [17437] = 6, + ACTIONS(3), 1, + sym__comment, + ACTIONS(689), 1, + anon_sym_DASH_GT, + STATE(186), 1, + sym_math_operator, + STATE(187), 1, + sym_logic_operator, + ACTIONS(196), 3, + anon_sym_DASH, + anon_sym_GT, + anon_sym_LT, + ACTIONS(194), 11, + anon_sym_RPAREN, + anon_sym_PLUS, + anon_sym_STAR, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + [17468] = 6, + ACTIONS(3), 1, + sym__comment, + ACTIONS(689), 1, anon_sym_DASH_GT, STATE(186), 1, sym_math_operator, @@ -18224,57 +18357,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_GT_EQ, anon_sym_LT_EQ, - [17387] = 9, - ACTIONS(3), 1, - sym__comment, - ACTIONS(326), 1, - anon_sym_DASH, - ACTIONS(629), 1, - anon_sym_DASH_GT, - ACTIONS(685), 1, - anon_sym_EQ_GT, - STATE(173), 1, - sym_logic_operator, - STATE(174), 1, - sym_math_operator, - ACTIONS(330), 2, - anon_sym_GT, - anon_sym_LT, - ACTIONS(324), 4, - anon_sym_PLUS, - anon_sym_STAR, - anon_sym_SLASH, - anon_sym_PERCENT, - ACTIONS(328), 6, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_AMP_AMP, - anon_sym_PIPE_PIPE, - anon_sym_GT_EQ, - anon_sym_LT_EQ, - [17424] = 3, - ACTIONS(3), 1, - sym__comment, - ACTIONS(689), 5, - anon_sym_LPAREN, - anon_sym_LBRACE, - sym_float, - sym_string, - anon_sym_LBRACK, - ACTIONS(687), 12, - sym_identifier, - sym_integer, - anon_sym_true, - anon_sym_false, - anon_sym_none, - anon_sym_some, - anon_sym_args, - anon_sym_assert_equal, - anon_sym_env, - anon_sym_length, - anon_sym_output, - anon_sym_random, - [17449] = 8, + [17499] = 8, ACTIONS(3), 1, sym__comment, ACTIONS(326), 1, @@ -18300,186 +18383,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_GT_EQ, anon_sym_LT_EQ, - [17483] = 8, - ACTIONS(3), 1, - sym__comment, - ACTIONS(326), 1, - anon_sym_DASH, - ACTIONS(342), 1, - anon_sym_DASH_GT, - STATE(173), 1, - sym_logic_operator, - STATE(174), 1, - sym_math_operator, - ACTIONS(330), 2, - anon_sym_GT, - anon_sym_LT, - ACTIONS(324), 4, - anon_sym_PLUS, - anon_sym_STAR, - anon_sym_SLASH, - anon_sym_PERCENT, - ACTIONS(328), 6, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_AMP_AMP, - anon_sym_PIPE_PIPE, - anon_sym_GT_EQ, - anon_sym_LT_EQ, - [17517] = 8, - ACTIONS(3), 1, - sym__comment, - ACTIONS(326), 1, - anon_sym_DASH, - ACTIONS(552), 1, - anon_sym_DASH_GT, - STATE(173), 1, - sym_logic_operator, - STATE(174), 1, - sym_math_operator, - ACTIONS(330), 2, - anon_sym_GT, - anon_sym_LT, - ACTIONS(324), 4, - anon_sym_PLUS, - anon_sym_STAR, - anon_sym_SLASH, - anon_sym_PERCENT, - ACTIONS(328), 6, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_AMP_AMP, - anon_sym_PIPE_PIPE, - anon_sym_GT_EQ, - anon_sym_LT_EQ, - [17551] = 8, - ACTIONS(3), 1, - sym__comment, - ACTIONS(326), 1, - anon_sym_DASH, - ACTIONS(562), 1, - anon_sym_DASH_GT, - STATE(173), 1, - sym_logic_operator, - STATE(174), 1, - sym_math_operator, - ACTIONS(330), 2, - anon_sym_GT, - anon_sym_LT, - ACTIONS(324), 4, - anon_sym_PLUS, - anon_sym_STAR, - anon_sym_SLASH, - anon_sym_PERCENT, - ACTIONS(328), 6, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_AMP_AMP, - anon_sym_PIPE_PIPE, - anon_sym_GT_EQ, - anon_sym_LT_EQ, - [17585] = 8, - ACTIONS(3), 1, - sym__comment, - ACTIONS(198), 1, - anon_sym_DASH_GT, - ACTIONS(326), 1, - anon_sym_DASH, - STATE(173), 1, - sym_logic_operator, - STATE(174), 1, - sym_math_operator, - ACTIONS(330), 2, - anon_sym_GT, - anon_sym_LT, - ACTIONS(324), 4, - anon_sym_PLUS, - anon_sym_STAR, - anon_sym_SLASH, - anon_sym_PERCENT, - ACTIONS(328), 6, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_AMP_AMP, - anon_sym_PIPE_PIPE, - anon_sym_GT_EQ, - anon_sym_LT_EQ, - [17619] = 8, - ACTIONS(3), 1, - sym__comment, - ACTIONS(204), 1, - anon_sym_DASH_GT, - ACTIONS(326), 1, - anon_sym_DASH, - STATE(173), 1, - sym_logic_operator, - STATE(174), 1, - sym_math_operator, - ACTIONS(330), 2, - anon_sym_GT, - anon_sym_LT, - ACTIONS(324), 4, - anon_sym_PLUS, - anon_sym_STAR, - anon_sym_SLASH, - anon_sym_PERCENT, - ACTIONS(328), 6, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_AMP_AMP, - anon_sym_PIPE_PIPE, - anon_sym_GT_EQ, - anon_sym_LT_EQ, - [17653] = 8, - ACTIONS(3), 1, - sym__comment, - ACTIONS(326), 1, - anon_sym_DASH, - ACTIONS(637), 1, - anon_sym_DASH_GT, - STATE(173), 1, - sym_logic_operator, - STATE(174), 1, - sym_math_operator, - ACTIONS(330), 2, - anon_sym_GT, - anon_sym_LT, - ACTIONS(324), 4, - anon_sym_PLUS, - anon_sym_STAR, - anon_sym_SLASH, - anon_sym_PERCENT, - ACTIONS(328), 6, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_AMP_AMP, - anon_sym_PIPE_PIPE, - anon_sym_GT_EQ, - anon_sym_LT_EQ, - [17687] = 5, - ACTIONS(3), 1, - sym__comment, - ACTIONS(210), 1, - anon_sym_LPAREN, - ACTIONS(691), 1, - anon_sym_RPAREN, - ACTIONS(208), 3, - anon_sym_DASH, - anon_sym_GT, - anon_sym_LT, - ACTIONS(206), 11, - anon_sym_PLUS, - anon_sym_STAR, - anon_sym_SLASH, - anon_sym_PERCENT, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_AMP_AMP, - anon_sym_PIPE_PIPE, - anon_sym_GT_EQ, - anon_sym_LT_EQ, - anon_sym_DASH_GT, - [17715] = 8, + [17533] = 8, ACTIONS(3), 1, sym__comment, ACTIONS(318), 1, @@ -18505,12 +18409,58 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_GT_EQ, anon_sym_LT_EQ, - [17749] = 8, + [17567] = 8, + ACTIONS(3), 1, + sym__comment, + ACTIONS(198), 1, + anon_sym_DASH_GT, + ACTIONS(326), 1, + anon_sym_DASH, + STATE(173), 1, + sym_logic_operator, + STATE(174), 1, + sym_math_operator, + ACTIONS(330), 2, + anon_sym_GT, + anon_sym_LT, + ACTIONS(324), 4, + anon_sym_PLUS, + anon_sym_STAR, + anon_sym_SLASH, + anon_sym_PERCENT, + ACTIONS(328), 6, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + [17601] = 2, + ACTIONS(3), 1, + sym__comment, + ACTIONS(699), 16, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_COMMA, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_none, + anon_sym_GT, + anon_sym_any, + anon_sym_bool, + anon_sym_collection, + anon_sym_float, + anon_sym_int, + anon_sym_map, + anon_sym_num, + anon_sym_str, + anon_sym_option, + [17623] = 8, ACTIONS(3), 1, sym__comment, ACTIONS(326), 1, anon_sym_DASH, - ACTIONS(334), 1, + ACTIONS(552), 1, anon_sym_DASH_GT, STATE(173), 1, sym_logic_operator, @@ -18531,76 +18481,12 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_GT_EQ, anon_sym_LT_EQ, - [17783] = 5, + [17657] = 5, ACTIONS(3), 1, sym__comment, ACTIONS(210), 1, anon_sym_LPAREN, - ACTIONS(693), 1, - anon_sym_RPAREN, - ACTIONS(208), 3, - anon_sym_DASH, - anon_sym_GT, - anon_sym_LT, - ACTIONS(206), 11, - anon_sym_PLUS, - anon_sym_STAR, - anon_sym_SLASH, - anon_sym_PERCENT, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_AMP_AMP, - anon_sym_PIPE_PIPE, - anon_sym_GT_EQ, - anon_sym_LT_EQ, - anon_sym_DASH_GT, - [17811] = 3, - ACTIONS(3), 1, - sym__comment, - ACTIONS(697), 1, - anon_sym_DASH_GT, - ACTIONS(695), 15, - anon_sym_LPAREN, - anon_sym_RPAREN, - anon_sym_COMMA, - anon_sym_LBRACK, - anon_sym_RBRACK, - anon_sym_none, - anon_sym_GT, - anon_sym_any, - anon_sym_bool, - anon_sym_float, - anon_sym_int, - anon_sym_map, - anon_sym_num, - anon_sym_str, - anon_sym_option, - [17835] = 3, - ACTIONS(3), 1, - sym__comment, ACTIONS(701), 1, - anon_sym_DASH_GT, - ACTIONS(699), 15, - anon_sym_LPAREN, - anon_sym_RPAREN, - anon_sym_COMMA, - anon_sym_LBRACK, - anon_sym_RBRACK, - anon_sym_none, - anon_sym_GT, - anon_sym_any, - anon_sym_bool, - anon_sym_float, - anon_sym_int, - anon_sym_map, - anon_sym_num, - anon_sym_str, - anon_sym_option, - [17859] = 4, - ACTIONS(3), 1, - sym__comment, - ACTIONS(210), 2, - anon_sym_LPAREN, anon_sym_RPAREN, ACTIONS(208), 3, anon_sym_DASH, @@ -18618,7 +18504,99 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_GT_EQ, anon_sym_LT_EQ, anon_sym_DASH_GT, - [17885] = 8, + [17685] = 2, + ACTIONS(3), 1, + sym__comment, + ACTIONS(703), 16, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_COMMA, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_none, + anon_sym_GT, + anon_sym_any, + anon_sym_bool, + anon_sym_collection, + anon_sym_float, + anon_sym_int, + anon_sym_map, + anon_sym_num, + anon_sym_str, + anon_sym_option, + [17707] = 8, + ACTIONS(3), 1, + sym__comment, + ACTIONS(326), 1, + anon_sym_DASH, + ACTIONS(562), 1, + anon_sym_DASH_GT, + STATE(173), 1, + sym_logic_operator, + STATE(174), 1, + sym_math_operator, + ACTIONS(330), 2, + anon_sym_GT, + anon_sym_LT, + ACTIONS(324), 4, + anon_sym_PLUS, + anon_sym_STAR, + anon_sym_SLASH, + anon_sym_PERCENT, + ACTIONS(328), 6, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + [17741] = 2, + ACTIONS(3), 1, + sym__comment, + ACTIONS(669), 16, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_COMMA, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_none, + anon_sym_GT, + anon_sym_any, + anon_sym_bool, + anon_sym_collection, + anon_sym_float, + anon_sym_int, + anon_sym_map, + anon_sym_num, + anon_sym_str, + anon_sym_option, + [17763] = 8, + ACTIONS(3), 1, + sym__comment, + ACTIONS(204), 1, + anon_sym_DASH_GT, + ACTIONS(326), 1, + anon_sym_DASH, + STATE(173), 1, + sym_logic_operator, + STATE(174), 1, + sym_math_operator, + ACTIONS(330), 2, + anon_sym_GT, + anon_sym_LT, + ACTIONS(324), 4, + anon_sym_PLUS, + anon_sym_STAR, + anon_sym_SLASH, + anon_sym_PERCENT, + ACTIONS(328), 6, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + [17797] = 8, ACTIONS(3), 1, sym__comment, ACTIONS(326), 1, @@ -18644,12 +18622,34 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_GT_EQ, anon_sym_LT_EQ, - [17919] = 8, + [17831] = 4, + ACTIONS(3), 1, + sym__comment, + ACTIONS(210), 2, + anon_sym_LPAREN, + anon_sym_RPAREN, + ACTIONS(208), 3, + anon_sym_DASH, + anon_sym_GT, + anon_sym_LT, + ACTIONS(206), 11, + anon_sym_PLUS, + anon_sym_STAR, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + anon_sym_DASH_GT, + [17857] = 8, ACTIONS(3), 1, sym__comment, ACTIONS(326), 1, anon_sym_DASH, - ACTIONS(671), 1, + ACTIONS(689), 1, anon_sym_DASH_GT, STATE(173), 1, sym_logic_operator, @@ -18670,12 +18670,38 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_GT_EQ, anon_sym_LT_EQ, - [17953] = 8, + [17891] = 8, ACTIONS(3), 1, sym__comment, ACTIONS(326), 1, anon_sym_DASH, - ACTIONS(671), 1, + ACTIONS(637), 1, + anon_sym_DASH_GT, + STATE(173), 1, + sym_logic_operator, + STATE(174), 1, + sym_math_operator, + ACTIONS(330), 2, + anon_sym_GT, + anon_sym_LT, + ACTIONS(324), 4, + anon_sym_PLUS, + anon_sym_STAR, + anon_sym_SLASH, + anon_sym_PERCENT, + ACTIONS(328), 6, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + [17925] = 8, + ACTIONS(3), 1, + sym__comment, + ACTIONS(326), 1, + anon_sym_DASH, + ACTIONS(689), 1, anon_sym_DASH_GT, STATE(186), 1, sym_math_operator, @@ -18696,12 +18722,12 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_GT_EQ, anon_sym_LT_EQ, - [17987] = 5, + [17959] = 5, ACTIONS(3), 1, sym__comment, ACTIONS(210), 1, anon_sym_LPAREN, - ACTIONS(703), 1, + ACTIONS(705), 1, anon_sym_RPAREN, ACTIONS(208), 3, anon_sym_DASH, @@ -18719,52 +18745,62 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_GT_EQ, anon_sym_LT_EQ, anon_sym_DASH_GT, - [18015] = 4, + [17987] = 8, ACTIONS(3), 1, sym__comment, - ACTIONS(705), 1, - anon_sym_RPAREN, - ACTIONS(276), 3, + ACTIONS(326), 1, anon_sym_DASH, + ACTIONS(342), 1, + anon_sym_DASH_GT, + STATE(173), 1, + sym_logic_operator, + STATE(174), 1, + sym_math_operator, + ACTIONS(330), 2, anon_sym_GT, anon_sym_LT, - ACTIONS(274), 11, + ACTIONS(324), 4, anon_sym_PLUS, anon_sym_STAR, anon_sym_SLASH, anon_sym_PERCENT, + ACTIONS(328), 6, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_AMP_AMP, anon_sym_PIPE_PIPE, anon_sym_GT_EQ, anon_sym_LT_EQ, - anon_sym_DASH_GT, - [18040] = 4, + [18021] = 8, ACTIONS(3), 1, sym__comment, - ACTIONS(707), 1, - anon_sym_RPAREN, - ACTIONS(276), 3, + ACTIONS(326), 1, anon_sym_DASH, + ACTIONS(334), 1, + anon_sym_DASH_GT, + STATE(173), 1, + sym_logic_operator, + STATE(174), 1, + sym_math_operator, + ACTIONS(330), 2, anon_sym_GT, anon_sym_LT, - ACTIONS(274), 11, + ACTIONS(324), 4, anon_sym_PLUS, anon_sym_STAR, anon_sym_SLASH, anon_sym_PERCENT, + ACTIONS(328), 6, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_AMP_AMP, anon_sym_PIPE_PIPE, anon_sym_GT_EQ, anon_sym_LT_EQ, - anon_sym_DASH_GT, - [18065] = 2, + [18055] = 2, ACTIONS(3), 1, sym__comment, - ACTIONS(709), 15, + ACTIONS(707), 16, anon_sym_LPAREN, anon_sym_RPAREN, anon_sym_COMMA, @@ -18774,13 +18810,37 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_GT, anon_sym_any, anon_sym_bool, + anon_sym_collection, anon_sym_float, anon_sym_int, anon_sym_map, anon_sym_num, anon_sym_str, anon_sym_option, - [18086] = 4, + [18077] = 5, + ACTIONS(3), 1, + sym__comment, + ACTIONS(210), 1, + anon_sym_LPAREN, + ACTIONS(709), 1, + anon_sym_RPAREN, + ACTIONS(208), 3, + anon_sym_DASH, + anon_sym_GT, + anon_sym_LT, + ACTIONS(206), 11, + anon_sym_PLUS, + anon_sym_STAR, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + anon_sym_DASH_GT, + [18105] = 4, ACTIONS(3), 1, sym__comment, ACTIONS(711), 1, @@ -18801,270 +18861,265 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_GT_EQ, anon_sym_LT_EQ, anon_sym_DASH_GT, - [18111] = 2, + [18130] = 4, ACTIONS(3), 1, sym__comment, - ACTIONS(699), 15, - anon_sym_LPAREN, + ACTIONS(713), 1, anon_sym_RPAREN, - anon_sym_COMMA, - anon_sym_LBRACK, - anon_sym_RBRACK, - anon_sym_none, + ACTIONS(276), 3, + anon_sym_DASH, anon_sym_GT, - anon_sym_any, - anon_sym_bool, - anon_sym_float, - anon_sym_int, - anon_sym_map, - anon_sym_num, - anon_sym_str, - anon_sym_option, - [18132] = 2, + anon_sym_LT, + ACTIONS(274), 11, + anon_sym_PLUS, + anon_sym_STAR, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + anon_sym_DASH_GT, + [18155] = 8, ACTIONS(3), 1, sym__comment, - ACTIONS(713), 15, + ACTIONS(715), 1, anon_sym_LPAREN, - anon_sym_RPAREN, - anon_sym_COMMA, - anon_sym_LBRACK, - anon_sym_RBRACK, - anon_sym_none, - anon_sym_GT, - anon_sym_any, - anon_sym_bool, - anon_sym_float, - anon_sym_int, - anon_sym_map, - anon_sym_num, - anon_sym_str, - anon_sym_option, - [18153] = 2, - ACTIONS(3), 1, - sym__comment, - ACTIONS(715), 15, - anon_sym_LPAREN, - anon_sym_RPAREN, - anon_sym_COMMA, - anon_sym_LBRACK, - anon_sym_RBRACK, - anon_sym_none, - anon_sym_GT, - anon_sym_any, - anon_sym_bool, - anon_sym_float, - anon_sym_int, - anon_sym_map, - anon_sym_num, - anon_sym_str, - anon_sym_option, - [18174] = 8, - ACTIONS(3), 1, - sym__comment, ACTIONS(717), 1, - anon_sym_LPAREN, - ACTIONS(720), 1, anon_sym_RPAREN, - ACTIONS(722), 1, + ACTIONS(719), 1, anon_sym_LBRACK, - ACTIONS(728), 1, + ACTIONS(723), 1, anon_sym_option, STATE(361), 1, aux_sym_type_repeat1, STATE(364), 1, sym_type, - ACTIONS(725), 8, + ACTIONS(721), 9, anon_sym_none, anon_sym_any, anon_sym_bool, + anon_sym_collection, anon_sym_float, anon_sym_int, anon_sym_map, anon_sym_num, anon_sym_str, - [18206] = 8, + [18188] = 8, ACTIONS(3), 1, sym__comment, - ACTIONS(731), 1, + ACTIONS(715), 1, anon_sym_LPAREN, - ACTIONS(733), 1, - anon_sym_RPAREN, - ACTIONS(735), 1, + ACTIONS(719), 1, anon_sym_LBRACK, - ACTIONS(739), 1, + ACTIONS(723), 1, anon_sym_option, - STATE(361), 1, + ACTIONS(725), 1, + anon_sym_RPAREN, + STATE(363), 1, aux_sym_type_repeat1, STATE(364), 1, sym_type, - ACTIONS(737), 8, + ACTIONS(721), 9, anon_sym_none, anon_sym_any, anon_sym_bool, + anon_sym_collection, anon_sym_float, anon_sym_int, anon_sym_map, anon_sym_num, anon_sym_str, - [18238] = 8, + [18221] = 4, ACTIONS(3), 1, sym__comment, - ACTIONS(731), 1, - anon_sym_LPAREN, - ACTIONS(735), 1, - anon_sym_LBRACK, - ACTIONS(739), 1, - anon_sym_option, - ACTIONS(741), 1, + ACTIONS(727), 1, anon_sym_RPAREN, - STATE(362), 1, + ACTIONS(276), 3, + anon_sym_DASH, + anon_sym_GT, + anon_sym_LT, + ACTIONS(274), 11, + anon_sym_PLUS, + anon_sym_STAR, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_PIPE_PIPE, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + anon_sym_DASH_GT, + [18246] = 8, + ACTIONS(3), 1, + sym__comment, + ACTIONS(729), 1, + anon_sym_LPAREN, + ACTIONS(732), 1, + anon_sym_RPAREN, + ACTIONS(734), 1, + anon_sym_LBRACK, + ACTIONS(740), 1, + anon_sym_option, + STATE(363), 1, aux_sym_type_repeat1, STATE(364), 1, sym_type, - ACTIONS(737), 8, + ACTIONS(737), 9, anon_sym_none, anon_sym_any, anon_sym_bool, + anon_sym_collection, anon_sym_float, anon_sym_int, anon_sym_map, anon_sym_num, anon_sym_str, - [18270] = 3, + [18279] = 3, ACTIONS(3), 1, sym__comment, ACTIONS(745), 1, anon_sym_COMMA, - ACTIONS(743), 12, + ACTIONS(743), 13, anon_sym_LPAREN, anon_sym_RPAREN, anon_sym_LBRACK, anon_sym_none, anon_sym_any, anon_sym_bool, + anon_sym_collection, anon_sym_float, anon_sym_int, anon_sym_map, anon_sym_num, anon_sym_str, anon_sym_option, - [18291] = 6, + [18301] = 6, ACTIONS(3), 1, sym__comment, - ACTIONS(731), 1, + ACTIONS(715), 1, anon_sym_LPAREN, - ACTIONS(735), 1, + ACTIONS(719), 1, anon_sym_LBRACK, - ACTIONS(739), 1, + ACTIONS(723), 1, anon_sym_option, STATE(356), 1, sym_type, - ACTIONS(737), 8, + ACTIONS(721), 9, anon_sym_none, anon_sym_any, anon_sym_bool, + anon_sym_collection, anon_sym_float, anon_sym_int, anon_sym_map, anon_sym_num, anon_sym_str, - [18317] = 6, + [18328] = 6, ACTIONS(3), 1, sym__comment, - ACTIONS(731), 1, + ACTIONS(715), 1, anon_sym_LPAREN, - ACTIONS(735), 1, + ACTIONS(719), 1, anon_sym_LBRACK, - ACTIONS(739), 1, + ACTIONS(723), 1, anon_sym_option, - STATE(360), 1, + STATE(341), 1, sym_type, - ACTIONS(737), 8, + ACTIONS(721), 9, anon_sym_none, anon_sym_any, anon_sym_bool, + anon_sym_collection, anon_sym_float, anon_sym_int, anon_sym_map, anon_sym_num, anon_sym_str, - [18343] = 6, + [18355] = 6, ACTIONS(3), 1, sym__comment, - ACTIONS(731), 1, + ACTIONS(715), 1, anon_sym_LPAREN, - ACTIONS(735), 1, + ACTIONS(719), 1, anon_sym_LBRACK, - ACTIONS(739), 1, + ACTIONS(723), 1, anon_sym_option, STATE(419), 1, sym_type, - ACTIONS(737), 8, + ACTIONS(721), 9, anon_sym_none, anon_sym_any, anon_sym_bool, + anon_sym_collection, anon_sym_float, anon_sym_int, anon_sym_map, anon_sym_num, anon_sym_str, - [18369] = 6, + [18382] = 6, ACTIONS(3), 1, sym__comment, - ACTIONS(731), 1, + ACTIONS(715), 1, anon_sym_LPAREN, - ACTIONS(735), 1, + ACTIONS(719), 1, anon_sym_LBRACK, - ACTIONS(739), 1, + ACTIONS(723), 1, anon_sym_option, STATE(426), 1, sym_type, - ACTIONS(737), 8, + ACTIONS(721), 9, anon_sym_none, anon_sym_any, anon_sym_bool, + anon_sym_collection, anon_sym_float, anon_sym_int, anon_sym_map, anon_sym_num, anon_sym_str, - [18395] = 2, + [18409] = 2, ACTIONS(3), 1, sym__comment, - ACTIONS(720), 12, + ACTIONS(732), 13, anon_sym_LPAREN, anon_sym_RPAREN, anon_sym_LBRACK, anon_sym_none, anon_sym_any, anon_sym_bool, + anon_sym_collection, anon_sym_float, anon_sym_int, anon_sym_map, anon_sym_num, anon_sym_str, anon_sym_option, - [18413] = 6, + [18428] = 6, ACTIONS(3), 1, sym__comment, - ACTIONS(731), 1, + ACTIONS(715), 1, anon_sym_LPAREN, - ACTIONS(735), 1, + ACTIONS(719), 1, anon_sym_LBRACK, - ACTIONS(739), 1, + ACTIONS(723), 1, anon_sym_option, STATE(421), 1, sym_type, - ACTIONS(737), 8, + ACTIONS(721), 9, anon_sym_none, anon_sym_any, anon_sym_bool, + anon_sym_collection, anon_sym_float, anon_sym_int, anon_sym_map, anon_sym_num, anon_sym_str, - [18439] = 7, + [18455] = 7, ACTIONS(3), 1, sym__comment, ACTIONS(543), 1, @@ -19082,7 +19137,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_SEMI, anon_sym_COMMA, anon_sym_RBRACE, - [18464] = 7, + [18480] = 7, ACTIONS(3), 1, sym__comment, ACTIONS(535), 1, @@ -19100,7 +19155,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_SEMI, anon_sym_COMMA, anon_sym_RBRACE, - [18489] = 3, + [18505] = 3, ACTIONS(3), 1, sym__comment, ACTIONS(749), 2, @@ -19113,7 +19168,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_EQ, anon_sym_PLUS_EQ, anon_sym_DASH_EQ, - [18505] = 3, + [18521] = 3, ACTIONS(3), 1, sym__comment, STATE(31), 1, @@ -19122,7 +19177,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_EQ, anon_sym_PLUS_EQ, anon_sym_DASH_EQ, - [18517] = 3, + [18533] = 3, ACTIONS(3), 1, sym__comment, STATE(42), 1, @@ -19131,7 +19186,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_EQ, anon_sym_PLUS_EQ, anon_sym_DASH_EQ, - [18529] = 3, + [18545] = 3, ACTIONS(3), 1, sym__comment, STATE(27), 1, @@ -19140,7 +19195,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_EQ, anon_sym_PLUS_EQ, anon_sym_DASH_EQ, - [18541] = 4, + [18557] = 4, ACTIONS(3), 1, sym__comment, ACTIONS(753), 1, @@ -19150,7 +19205,7 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(218), 2, anon_sym_PLUS_EQ, anon_sym_DASH_EQ, - [18555] = 4, + [18571] = 4, ACTIONS(3), 1, sym__comment, ACTIONS(659), 1, @@ -19159,7 +19214,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACE, STATE(255), 1, sym_block, - [18568] = 4, + [18584] = 4, ACTIONS(3), 1, sym__comment, ACTIONS(655), 1, @@ -19168,7 +19223,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACE, STATE(296), 1, sym_block, - [18581] = 4, + [18597] = 4, ACTIONS(3), 1, sym__comment, ACTIONS(755), 1, @@ -19177,7 +19232,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RBRACE, STATE(395), 1, aux_sym_map_repeat1, - [18594] = 4, + [18610] = 4, ACTIONS(3), 1, sym__comment, ACTIONS(647), 1, @@ -19186,7 +19241,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACE, STATE(296), 1, sym_block, - [18607] = 4, + [18623] = 4, ACTIONS(3), 1, sym__comment, ACTIONS(647), 1, @@ -19195,7 +19250,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACE, STATE(235), 1, sym_block, - [18620] = 4, + [18636] = 4, ACTIONS(3), 1, sym__comment, ACTIONS(659), 1, @@ -19204,7 +19259,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACE, STATE(62), 1, sym_block, - [18633] = 4, + [18649] = 4, ACTIONS(3), 1, sym__comment, ACTIONS(759), 1, @@ -19213,7 +19268,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RPAREN, STATE(398), 1, aux_sym_function_repeat1, - [18646] = 4, + [18662] = 4, ACTIONS(3), 1, sym__comment, ACTIONS(647), 1, @@ -19222,7 +19277,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACE, STATE(228), 1, sym_block, - [18659] = 4, + [18675] = 4, ACTIONS(3), 1, sym__comment, ACTIONS(759), 1, @@ -19231,7 +19286,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RPAREN, STATE(398), 1, aux_sym_function_repeat1, - [18672] = 4, + [18688] = 4, ACTIONS(3), 1, sym__comment, ACTIONS(755), 1, @@ -19240,7 +19295,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RBRACE, STATE(395), 1, aux_sym_map_repeat1, - [18685] = 3, + [18701] = 3, ACTIONS(3), 1, sym__comment, ACTIONS(769), 1, @@ -19248,7 +19303,7 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(767), 2, anon_sym_RBRACE, sym_identifier, - [18696] = 4, + [18712] = 4, ACTIONS(3), 1, sym__comment, ACTIONS(655), 1, @@ -19257,7 +19312,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACE, STATE(95), 1, sym_block, - [18709] = 3, + [18725] = 3, ACTIONS(3), 1, sym__comment, ACTIONS(773), 1, @@ -19265,7 +19320,7 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(771), 2, anon_sym_RBRACE, sym_identifier, - [18720] = 4, + [18736] = 4, ACTIONS(3), 1, sym__comment, ACTIONS(759), 1, @@ -19274,7 +19329,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RPAREN, STATE(398), 1, aux_sym_function_repeat1, - [18733] = 4, + [18749] = 4, ACTIONS(3), 1, sym__comment, ACTIONS(659), 1, @@ -19283,7 +19338,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACE, STATE(60), 1, sym_block, - [18746] = 4, + [18762] = 4, ACTIONS(3), 1, sym__comment, ACTIONS(755), 1, @@ -19292,7 +19347,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RBRACE, STATE(395), 1, aux_sym_map_repeat1, - [18759] = 3, + [18775] = 3, ACTIONS(3), 1, sym__comment, ACTIONS(781), 1, @@ -19300,7 +19355,7 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(779), 2, anon_sym_RPAREN, sym_identifier, - [18770] = 4, + [18786] = 4, ACTIONS(3), 1, sym__comment, ACTIONS(783), 1, @@ -19309,7 +19364,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RBRACE, STATE(395), 1, aux_sym_map_repeat1, - [18783] = 4, + [18799] = 4, ACTIONS(3), 1, sym__comment, ACTIONS(788), 1, @@ -19318,7 +19373,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LT, STATE(424), 1, sym_type_definition, - [18796] = 4, + [18812] = 4, ACTIONS(3), 1, sym__comment, ACTIONS(655), 1, @@ -19327,7 +19382,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACE, STATE(96), 1, sym_block, - [18809] = 4, + [18825] = 4, ACTIONS(3), 1, sym__comment, ACTIONS(779), 1, @@ -19336,266 +19391,266 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, STATE(398), 1, aux_sym_function_repeat1, - [18822] = 3, + [18838] = 3, ACTIONS(3), 1, sym__comment, ACTIONS(790), 1, anon_sym_LT, STATE(385), 1, sym_type_definition, - [18832] = 3, + [18848] = 3, ACTIONS(3), 1, sym__comment, ACTIONS(755), 1, sym_identifier, STATE(387), 1, aux_sym_map_repeat1, - [18842] = 3, + [18858] = 3, ACTIONS(3), 1, sym__comment, ACTIONS(250), 1, anon_sym_LPAREN, ACTIONS(795), 1, anon_sym_RPAREN, - [18852] = 3, + [18868] = 3, ACTIONS(3), 1, sym__comment, ACTIONS(790), 1, anon_sym_LT, STATE(389), 1, sym_type_definition, - [18862] = 3, + [18878] = 3, ACTIONS(3), 1, sym__comment, ACTIONS(790), 1, anon_sym_LT, STATE(392), 1, sym_type_definition, - [18872] = 3, + [18888] = 3, ACTIONS(3), 1, sym__comment, ACTIONS(790), 1, anon_sym_LT, STATE(394), 1, sym_type_definition, - [18882] = 3, + [18898] = 3, ACTIONS(3), 1, sym__comment, ACTIONS(790), 1, anon_sym_LT, STATE(383), 1, sym_type_definition, - [18892] = 2, + [18908] = 2, ACTIONS(3), 1, sym__comment, ACTIONS(767), 2, anon_sym_RBRACE, sym_identifier, - [18900] = 2, + [18916] = 2, ACTIONS(3), 1, sym__comment, ACTIONS(797), 2, anon_sym_RBRACE, sym_identifier, - [18908] = 3, + [18924] = 3, ACTIONS(3), 1, sym__comment, ACTIONS(755), 1, sym_identifier, STATE(380), 1, aux_sym_map_repeat1, - [18918] = 3, + [18934] = 3, ACTIONS(3), 1, sym__comment, ACTIONS(250), 1, anon_sym_LPAREN, ACTIONS(799), 1, anon_sym_RPAREN, - [18928] = 3, + [18944] = 3, ACTIONS(3), 1, sym__comment, ACTIONS(790), 1, anon_sym_LT, STATE(382), 1, sym_type_definition, - [18938] = 3, + [18954] = 3, ACTIONS(3), 1, sym__comment, ACTIONS(755), 1, sym_identifier, STATE(393), 1, aux_sym_map_repeat1, - [18948] = 2, + [18964] = 2, ACTIONS(3), 1, sym__comment, ACTIONS(801), 2, anon_sym_RPAREN, sym_identifier, - [18956] = 3, + [18972] = 3, ACTIONS(3), 1, sym__comment, ACTIONS(250), 1, anon_sym_LPAREN, ACTIONS(803), 1, anon_sym_RPAREN, - [18966] = 3, + [18982] = 3, ACTIONS(3), 1, sym__comment, ACTIONS(790), 1, anon_sym_LT, STATE(397), 1, sym_type_definition, - [18976] = 2, + [18992] = 2, ACTIONS(3), 1, sym__comment, ACTIONS(805), 1, anon_sym_COLON, - [18983] = 2, + [18999] = 2, ACTIONS(3), 1, sym__comment, ACTIONS(807), 1, anon_sym_LBRACE, - [18990] = 2, + [19006] = 2, ACTIONS(3), 1, sym__comment, ACTIONS(809), 1, anon_sym_LPAREN, - [18997] = 2, + [19013] = 2, ACTIONS(3), 1, sym__comment, ACTIONS(811), 1, anon_sym_in, - [19004] = 2, + [19020] = 2, ACTIONS(3), 1, sym__comment, ACTIONS(813), 1, anon_sym_GT, - [19011] = 2, + [19027] = 2, ACTIONS(3), 1, sym__comment, ACTIONS(815), 1, anon_sym_COLON, - [19018] = 2, + [19034] = 2, ACTIONS(3), 1, sym__comment, ACTIONS(817), 1, anon_sym_RBRACK, - [19025] = 2, + [19041] = 2, ACTIONS(3), 1, sym__comment, ACTIONS(819), 1, anon_sym_LBRACE, - [19032] = 2, + [19048] = 2, ACTIONS(3), 1, sym__comment, ACTIONS(821), 1, anon_sym_COLON, - [19039] = 2, + [19055] = 2, ACTIONS(3), 1, sym__comment, ACTIONS(823), 1, anon_sym_EQ, - [19046] = 2, + [19062] = 2, ACTIONS(3), 1, sym__comment, ACTIONS(825), 1, anon_sym_in, - [19053] = 2, + [19069] = 2, ACTIONS(3), 1, sym__comment, ACTIONS(827), 1, anon_sym_RPAREN, - [19060] = 2, + [19076] = 2, ACTIONS(3), 1, sym__comment, ACTIONS(829), 1, anon_sym_LPAREN, - [19067] = 2, + [19083] = 2, ACTIONS(3), 1, sym__comment, ACTIONS(831), 1, anon_sym_LBRACE, - [19074] = 2, + [19090] = 2, ACTIONS(3), 1, sym__comment, ACTIONS(833), 1, anon_sym_in, - [19081] = 2, + [19097] = 2, ACTIONS(3), 1, sym__comment, ACTIONS(835), 1, anon_sym_COLON, - [19088] = 2, + [19104] = 2, ACTIONS(3), 1, sym__comment, ACTIONS(837), 1, anon_sym_LBRACE, - [19095] = 2, + [19111] = 2, ACTIONS(3), 1, sym__comment, ACTIONS(839), 1, anon_sym_LPAREN, - [19102] = 2, + [19118] = 2, ACTIONS(3), 1, sym__comment, ACTIONS(841), 1, sym_identifier, - [19109] = 2, + [19125] = 2, ACTIONS(3), 1, sym__comment, - ACTIONS(685), 1, + ACTIONS(673), 1, anon_sym_EQ_GT, - [19116] = 2, + [19132] = 2, ACTIONS(3), 1, sym__comment, ACTIONS(843), 1, anon_sym_COLON, - [19123] = 2, + [19139] = 2, ACTIONS(3), 1, sym__comment, ACTIONS(845), 1, anon_sym_LBRACE, - [19130] = 2, + [19146] = 2, ACTIONS(3), 1, sym__comment, ACTIONS(847), 1, anon_sym_LPAREN, - [19137] = 2, + [19153] = 2, ACTIONS(3), 1, sym__comment, ACTIONS(849), 1, anon_sym_COLON, - [19144] = 2, + [19160] = 2, ACTIONS(3), 1, sym__comment, ACTIONS(851), 1, anon_sym_LPAREN, - [19151] = 2, + [19167] = 2, ACTIONS(3), 1, sym__comment, ACTIONS(853), 1, ts_builtin_sym_end, - [19158] = 2, + [19174] = 2, ACTIONS(3), 1, sym__comment, ACTIONS(855), 1, sym_identifier, - [19165] = 2, + [19181] = 2, ACTIONS(3), 1, sym__comment, ACTIONS(857), 1, anon_sym_COLON, - [19172] = 2, + [19188] = 2, ACTIONS(3), 1, sym__comment, ACTIONS(859), 1, anon_sym_LPAREN, - [19179] = 2, + [19195] = 2, ACTIONS(3), 1, sym__comment, ACTIONS(861), 1, sym_identifier, - [19186] = 2, + [19202] = 2, ACTIONS(3), 1, sym__comment, ACTIONS(863), 1, @@ -19903,125 +19958,125 @@ static const uint32_t ts_small_parse_table_map[] = { [SMALL_STATE(324)] = 17059, [SMALL_STATE(325)] = 17087, [SMALL_STATE(326)] = 17115, - [SMALL_STATE(327)] = 17152, - [SMALL_STATE(328)] = 17183, - [SMALL_STATE(329)] = 17220, - [SMALL_STATE(330)] = 17257, - [SMALL_STATE(331)] = 17282, - [SMALL_STATE(332)] = 17319, - [SMALL_STATE(333)] = 17356, - [SMALL_STATE(334)] = 17387, - [SMALL_STATE(335)] = 17424, - [SMALL_STATE(336)] = 17449, - [SMALL_STATE(337)] = 17483, - [SMALL_STATE(338)] = 17517, - [SMALL_STATE(339)] = 17551, - [SMALL_STATE(340)] = 17585, - [SMALL_STATE(341)] = 17619, - [SMALL_STATE(342)] = 17653, - [SMALL_STATE(343)] = 17687, - [SMALL_STATE(344)] = 17715, - [SMALL_STATE(345)] = 17749, - [SMALL_STATE(346)] = 17783, - [SMALL_STATE(347)] = 17811, - [SMALL_STATE(348)] = 17835, - [SMALL_STATE(349)] = 17859, - [SMALL_STATE(350)] = 17885, - [SMALL_STATE(351)] = 17919, - [SMALL_STATE(352)] = 17953, - [SMALL_STATE(353)] = 17987, - [SMALL_STATE(354)] = 18015, - [SMALL_STATE(355)] = 18040, - [SMALL_STATE(356)] = 18065, - [SMALL_STATE(357)] = 18086, - [SMALL_STATE(358)] = 18111, - [SMALL_STATE(359)] = 18132, - [SMALL_STATE(360)] = 18153, - [SMALL_STATE(361)] = 18174, - [SMALL_STATE(362)] = 18206, - [SMALL_STATE(363)] = 18238, - [SMALL_STATE(364)] = 18270, - [SMALL_STATE(365)] = 18291, - [SMALL_STATE(366)] = 18317, - [SMALL_STATE(367)] = 18343, - [SMALL_STATE(368)] = 18369, - [SMALL_STATE(369)] = 18395, - [SMALL_STATE(370)] = 18413, - [SMALL_STATE(371)] = 18439, - [SMALL_STATE(372)] = 18464, - [SMALL_STATE(373)] = 18489, - [SMALL_STATE(374)] = 18505, - [SMALL_STATE(375)] = 18517, - [SMALL_STATE(376)] = 18529, - [SMALL_STATE(377)] = 18541, - [SMALL_STATE(378)] = 18555, - [SMALL_STATE(379)] = 18568, - [SMALL_STATE(380)] = 18581, - [SMALL_STATE(381)] = 18594, - [SMALL_STATE(382)] = 18607, - [SMALL_STATE(383)] = 18620, - [SMALL_STATE(384)] = 18633, - [SMALL_STATE(385)] = 18646, - [SMALL_STATE(386)] = 18659, - [SMALL_STATE(387)] = 18672, - [SMALL_STATE(388)] = 18685, - [SMALL_STATE(389)] = 18696, - [SMALL_STATE(390)] = 18709, - [SMALL_STATE(391)] = 18720, - [SMALL_STATE(392)] = 18733, - [SMALL_STATE(393)] = 18746, - [SMALL_STATE(394)] = 18759, - [SMALL_STATE(395)] = 18770, - [SMALL_STATE(396)] = 18783, - [SMALL_STATE(397)] = 18796, - [SMALL_STATE(398)] = 18809, - [SMALL_STATE(399)] = 18822, - [SMALL_STATE(400)] = 18832, - [SMALL_STATE(401)] = 18842, - [SMALL_STATE(402)] = 18852, - [SMALL_STATE(403)] = 18862, - [SMALL_STATE(404)] = 18872, - [SMALL_STATE(405)] = 18882, - [SMALL_STATE(406)] = 18892, - [SMALL_STATE(407)] = 18900, - [SMALL_STATE(408)] = 18908, - [SMALL_STATE(409)] = 18918, - [SMALL_STATE(410)] = 18928, - [SMALL_STATE(411)] = 18938, - [SMALL_STATE(412)] = 18948, - [SMALL_STATE(413)] = 18956, - [SMALL_STATE(414)] = 18966, - [SMALL_STATE(415)] = 18976, - [SMALL_STATE(416)] = 18983, - [SMALL_STATE(417)] = 18990, - [SMALL_STATE(418)] = 18997, - [SMALL_STATE(419)] = 19004, - [SMALL_STATE(420)] = 19011, - [SMALL_STATE(421)] = 19018, - [SMALL_STATE(422)] = 19025, - [SMALL_STATE(423)] = 19032, - [SMALL_STATE(424)] = 19039, - [SMALL_STATE(425)] = 19046, - [SMALL_STATE(426)] = 19053, - [SMALL_STATE(427)] = 19060, - [SMALL_STATE(428)] = 19067, - [SMALL_STATE(429)] = 19074, - [SMALL_STATE(430)] = 19081, - [SMALL_STATE(431)] = 19088, - [SMALL_STATE(432)] = 19095, - [SMALL_STATE(433)] = 19102, - [SMALL_STATE(434)] = 19109, - [SMALL_STATE(435)] = 19116, - [SMALL_STATE(436)] = 19123, - [SMALL_STATE(437)] = 19130, - [SMALL_STATE(438)] = 19137, - [SMALL_STATE(439)] = 19144, - [SMALL_STATE(440)] = 19151, - [SMALL_STATE(441)] = 19158, - [SMALL_STATE(442)] = 19165, - [SMALL_STATE(443)] = 19172, - [SMALL_STATE(444)] = 19179, - [SMALL_STATE(445)] = 19186, + [SMALL_STATE(327)] = 17140, + [SMALL_STATE(328)] = 17177, + [SMALL_STATE(329)] = 17214, + [SMALL_STATE(330)] = 17251, + [SMALL_STATE(331)] = 17276, + [SMALL_STATE(332)] = 17301, + [SMALL_STATE(333)] = 17338, + [SMALL_STATE(334)] = 17375, + [SMALL_STATE(335)] = 17412, + [SMALL_STATE(336)] = 17437, + [SMALL_STATE(337)] = 17468, + [SMALL_STATE(338)] = 17499, + [SMALL_STATE(339)] = 17533, + [SMALL_STATE(340)] = 17567, + [SMALL_STATE(341)] = 17601, + [SMALL_STATE(342)] = 17623, + [SMALL_STATE(343)] = 17657, + [SMALL_STATE(344)] = 17685, + [SMALL_STATE(345)] = 17707, + [SMALL_STATE(346)] = 17741, + [SMALL_STATE(347)] = 17763, + [SMALL_STATE(348)] = 17797, + [SMALL_STATE(349)] = 17831, + [SMALL_STATE(350)] = 17857, + [SMALL_STATE(351)] = 17891, + [SMALL_STATE(352)] = 17925, + [SMALL_STATE(353)] = 17959, + [SMALL_STATE(354)] = 17987, + [SMALL_STATE(355)] = 18021, + [SMALL_STATE(356)] = 18055, + [SMALL_STATE(357)] = 18077, + [SMALL_STATE(358)] = 18105, + [SMALL_STATE(359)] = 18130, + [SMALL_STATE(360)] = 18155, + [SMALL_STATE(361)] = 18188, + [SMALL_STATE(362)] = 18221, + [SMALL_STATE(363)] = 18246, + [SMALL_STATE(364)] = 18279, + [SMALL_STATE(365)] = 18301, + [SMALL_STATE(366)] = 18328, + [SMALL_STATE(367)] = 18355, + [SMALL_STATE(368)] = 18382, + [SMALL_STATE(369)] = 18409, + [SMALL_STATE(370)] = 18428, + [SMALL_STATE(371)] = 18455, + [SMALL_STATE(372)] = 18480, + [SMALL_STATE(373)] = 18505, + [SMALL_STATE(374)] = 18521, + [SMALL_STATE(375)] = 18533, + [SMALL_STATE(376)] = 18545, + [SMALL_STATE(377)] = 18557, + [SMALL_STATE(378)] = 18571, + [SMALL_STATE(379)] = 18584, + [SMALL_STATE(380)] = 18597, + [SMALL_STATE(381)] = 18610, + [SMALL_STATE(382)] = 18623, + [SMALL_STATE(383)] = 18636, + [SMALL_STATE(384)] = 18649, + [SMALL_STATE(385)] = 18662, + [SMALL_STATE(386)] = 18675, + [SMALL_STATE(387)] = 18688, + [SMALL_STATE(388)] = 18701, + [SMALL_STATE(389)] = 18712, + [SMALL_STATE(390)] = 18725, + [SMALL_STATE(391)] = 18736, + [SMALL_STATE(392)] = 18749, + [SMALL_STATE(393)] = 18762, + [SMALL_STATE(394)] = 18775, + [SMALL_STATE(395)] = 18786, + [SMALL_STATE(396)] = 18799, + [SMALL_STATE(397)] = 18812, + [SMALL_STATE(398)] = 18825, + [SMALL_STATE(399)] = 18838, + [SMALL_STATE(400)] = 18848, + [SMALL_STATE(401)] = 18858, + [SMALL_STATE(402)] = 18868, + [SMALL_STATE(403)] = 18878, + [SMALL_STATE(404)] = 18888, + [SMALL_STATE(405)] = 18898, + [SMALL_STATE(406)] = 18908, + [SMALL_STATE(407)] = 18916, + [SMALL_STATE(408)] = 18924, + [SMALL_STATE(409)] = 18934, + [SMALL_STATE(410)] = 18944, + [SMALL_STATE(411)] = 18954, + [SMALL_STATE(412)] = 18964, + [SMALL_STATE(413)] = 18972, + [SMALL_STATE(414)] = 18982, + [SMALL_STATE(415)] = 18992, + [SMALL_STATE(416)] = 18999, + [SMALL_STATE(417)] = 19006, + [SMALL_STATE(418)] = 19013, + [SMALL_STATE(419)] = 19020, + [SMALL_STATE(420)] = 19027, + [SMALL_STATE(421)] = 19034, + [SMALL_STATE(422)] = 19041, + [SMALL_STATE(423)] = 19048, + [SMALL_STATE(424)] = 19055, + [SMALL_STATE(425)] = 19062, + [SMALL_STATE(426)] = 19069, + [SMALL_STATE(427)] = 19076, + [SMALL_STATE(428)] = 19083, + [SMALL_STATE(429)] = 19090, + [SMALL_STATE(430)] = 19097, + [SMALL_STATE(431)] = 19104, + [SMALL_STATE(432)] = 19111, + [SMALL_STATE(433)] = 19118, + [SMALL_STATE(434)] = 19125, + [SMALL_STATE(435)] = 19132, + [SMALL_STATE(436)] = 19139, + [SMALL_STATE(437)] = 19146, + [SMALL_STATE(438)] = 19153, + [SMALL_STATE(439)] = 19160, + [SMALL_STATE(440)] = 19167, + [SMALL_STATE(441)] = 19174, + [SMALL_STATE(442)] = 19181, + [SMALL_STATE(443)] = 19188, + [SMALL_STATE(444)] = 19195, + [SMALL_STATE(445)] = 19202, }; static const TSParseActionEntry ts_parse_actions[] = { @@ -20335,41 +20390,41 @@ static const TSParseActionEntry ts_parse_actions[] = { [663] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym__expression_list, 2), [665] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_list_repeat1, 2), [667] = {.entry = {.count = 1, .reusable = true}}, SHIFT(185), - [669] = {.entry = {.count = 1, .reusable = true}}, SHIFT(54), - [671] = {.entry = {.count = 1, .reusable = true}}, SHIFT(159), - [673] = {.entry = {.count = 1, .reusable = true}}, SHIFT(131), - [675] = {.entry = {.count = 1, .reusable = true}}, SHIFT(137), - [677] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_math_operator, 1), - [679] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_math_operator, 1), - [681] = {.entry = {.count = 1, .reusable = true}}, SHIFT(94), - [683] = {.entry = {.count = 1, .reusable = true}}, SHIFT(234), - [685] = {.entry = {.count = 1, .reusable = true}}, SHIFT(34), - [687] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_logic_operator, 1), - [689] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_logic_operator, 1), - [691] = {.entry = {.count = 1, .reusable = true}}, SHIFT(74), - [693] = {.entry = {.count = 1, .reusable = true}}, SHIFT(93), - [695] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type, 2), - [697] = {.entry = {.count = 1, .reusable = true}}, SHIFT(366), - [699] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type, 3), - [701] = {.entry = {.count = 1, .reusable = true}}, SHIFT(365), - [703] = {.entry = {.count = 1, .reusable = true}}, SHIFT(250), - [705] = {.entry = {.count = 1, .reusable = true}}, SHIFT(72), - [707] = {.entry = {.count = 1, .reusable = true}}, SHIFT(100), - [709] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type, 5), - [711] = {.entry = {.count = 1, .reusable = true}}, SHIFT(224), - [713] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type, 1), - [715] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type, 4), - [717] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_type_repeat1, 2), SHIFT_REPEAT(363), - [720] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_type_repeat1, 2), - [722] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_type_repeat1, 2), SHIFT_REPEAT(370), - [725] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_type_repeat1, 2), SHIFT_REPEAT(359), - [728] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_type_repeat1, 2), SHIFT_REPEAT(417), - [731] = {.entry = {.count = 1, .reusable = true}}, SHIFT(363), - [733] = {.entry = {.count = 1, .reusable = true}}, SHIFT(348), - [735] = {.entry = {.count = 1, .reusable = true}}, SHIFT(370), - [737] = {.entry = {.count = 1, .reusable = true}}, SHIFT(359), - [739] = {.entry = {.count = 1, .reusable = true}}, SHIFT(417), - [741] = {.entry = {.count = 1, .reusable = true}}, SHIFT(347), + [669] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type, 3), + [671] = {.entry = {.count = 1, .reusable = true}}, SHIFT(365), + [673] = {.entry = {.count = 1, .reusable = true}}, SHIFT(34), + [675] = {.entry = {.count = 1, .reusable = true}}, SHIFT(131), + [677] = {.entry = {.count = 1, .reusable = true}}, SHIFT(137), + [679] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_math_operator, 1), + [681] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_math_operator, 1), + [683] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type, 2), + [685] = {.entry = {.count = 1, .reusable = true}}, SHIFT(366), + [687] = {.entry = {.count = 1, .reusable = true}}, SHIFT(54), + [689] = {.entry = {.count = 1, .reusable = true}}, SHIFT(159), + [691] = {.entry = {.count = 1, .reusable = true}}, SHIFT(94), + [693] = {.entry = {.count = 1, .reusable = true}}, SHIFT(234), + [695] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_logic_operator, 1), + [697] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_logic_operator, 1), + [699] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type, 4), + [701] = {.entry = {.count = 1, .reusable = true}}, SHIFT(74), + [703] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type, 1), + [705] = {.entry = {.count = 1, .reusable = true}}, SHIFT(250), + [707] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type, 5), + [709] = {.entry = {.count = 1, .reusable = true}}, SHIFT(93), + [711] = {.entry = {.count = 1, .reusable = true}}, SHIFT(100), + [713] = {.entry = {.count = 1, .reusable = true}}, SHIFT(224), + [715] = {.entry = {.count = 1, .reusable = true}}, SHIFT(360), + [717] = {.entry = {.count = 1, .reusable = true}}, SHIFT(331), + [719] = {.entry = {.count = 1, .reusable = true}}, SHIFT(370), + [721] = {.entry = {.count = 1, .reusable = true}}, SHIFT(344), + [723] = {.entry = {.count = 1, .reusable = true}}, SHIFT(417), + [725] = {.entry = {.count = 1, .reusable = true}}, SHIFT(326), + [727] = {.entry = {.count = 1, .reusable = true}}, SHIFT(72), + [729] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_type_repeat1, 2), SHIFT_REPEAT(360), + [732] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_type_repeat1, 2), + [734] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_type_repeat1, 2), SHIFT_REPEAT(370), + [737] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_type_repeat1, 2), SHIFT_REPEAT(344), + [740] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_type_repeat1, 2), SHIFT_REPEAT(417), [743] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_type_repeat1, 1), [745] = {.entry = {.count = 1, .reusable = true}}, SHIFT(369), [747] = {.entry = {.count = 1, .reusable = false}}, SHIFT(381), @@ -20406,12 +20461,12 @@ static const TSParseActionEntry ts_parse_actions[] = { [811] = {.entry = {.count = 1, .reusable = true}}, SHIFT(164), [813] = {.entry = {.count = 1, .reusable = true}}, SHIFT(373), [815] = {.entry = {.count = 1, .reusable = true}}, SHIFT(274), - [817] = {.entry = {.count = 1, .reusable = true}}, SHIFT(358), + [817] = {.entry = {.count = 1, .reusable = true}}, SHIFT(346), [819] = {.entry = {.count = 1, .reusable = true}}, SHIFT(10), [821] = {.entry = {.count = 1, .reusable = true}}, SHIFT(273), [823] = {.entry = {.count = 1, .reusable = true}}, SHIFT(39), [825] = {.entry = {.count = 1, .reusable = true}}, SHIFT(209), - [827] = {.entry = {.count = 1, .reusable = true}}, SHIFT(360), + [827] = {.entry = {.count = 1, .reusable = true}}, SHIFT(341), [829] = {.entry = {.count = 1, .reusable = true}}, SHIFT(127), [831] = {.entry = {.count = 1, .reusable = true}}, SHIFT(15), [833] = {.entry = {.count = 1, .reusable = true}}, SHIFT(163),